src/bin/e_client.c

   1 #include "e.h"
   2 #include "e_client_intern.h"
   3 #include "e_actions_intern.h"
   4 #include "e_appinfo_intern.h"
   5 #include "e_bindings_intern.h"
   6 #include "e_uuid_store_intern.h"
   7 #include "e_utils_intern.h"
   8 #include "e_comp_canvas_intern.h"
   9 #include "e_comp_wl_intern.h"
  10 #include "e_comp_wl_subsurface_intern.h"
  11 #include "e_comp_intern.h"
  12 #include "e_input_intern.h"
  13
  14 #define PRI(ec) ((E_Client_Private *)e_object_data_get(E_OBJECT(ec)))
  15
  16 #define API_ENTRY \
  17    EINA_SAFETY_ON_NULL_RETURN(ec); \
  18    E_Client_Private *priv = PRI(ec)
  19
  20 #define API_ENTRY_VAL(ret) \
  21    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, ret); \
  22    E_Client_Private *priv = PRI(ec)
  23
  24 typedef struct _E_Client_Private E_Client_Private;
  25
  26 struct _E_Client_Private
  27 {
  28    struct
  29      {
  30         struct wl_signal eval_pre_fetch;
  31         struct wl_signal eval_fetch;
  32         struct wl_signal eval_pre_post_fetch;
  33         struct wl_signal eval_post_fetch;
  34         struct wl_signal eval_pre_frame_assign;
  35         struct wl_signal eval_post_frame_assign;
  36         struct wl_signal eval_pre_new_client;
  37         struct wl_signal eval_post_new_client;
  38         struct wl_signal eval_visibility;
  39         struct wl_signal eval_visibility_end;
  40         struct wl_signal eval_end;
  41
  42         struct wl_signal move_begin;
  43         struct wl_signal move_update;
  44         struct wl_signal move_end;
  45         struct wl_signal move_resize_begin;
  46         struct wl_signal move_resize_update;
  47         struct wl_signal move_resize_end;
  48
  49         struct wl_signal destroy;
  50         struct wl_signal new_client;
  51         struct wl_signal new_client_post;
  52
  53         struct wl_signal unredirect;
  54         struct wl_signal redirect;
  55
  56         struct wl_signal aux_hint_change;
  57         struct wl_signal window_role_change;
  58         struct wl_signal transform_change;
  59         struct wl_signal activate_done;
  60
  61         struct wl_signal mouse_in;
  62         struct wl_signal mouse_out;
  63         struct wl_signal mouse_down;
  64
  65         struct wl_signal focus_set;
  66         struct wl_signal focus_unset;
  67         struct wl_signal focus_defer_set;
  68         struct wl_signal focus_latest_set;
  69
  70         struct wl_signal iconify;
  71         struct wl_signal uniconify;
  72         struct wl_signal maximize;
  73         struct wl_signal unmaximize;
  74         struct wl_signal fullscreen_pre;
  75         struct wl_signal fullscreen;
  76         struct wl_signal unfullscreen;
  77
  78         struct wl_signal move;
  79
  80         struct wl_signal set_layer;
  81         struct wl_signal raise;
  82         struct wl_signal lower;
  83         struct wl_signal stack_below;
  84         struct wl_signal stack_above;
  85         struct wl_signal stack_transient_for_done;
  86
  87         struct wl_signal stick;
  88         struct wl_signal unstick;
  89
  90 #ifdef REFACTOR_DESK_AREA
  91         struct wl_signal get_above;
  92         struct wl_signal get_below;
  93         struct wl_signal get_visible_above;
  94         struct wl_signal get_visible_below;
  95         struct wl_signal subsurface_stack_update;
  96 #endif
  97      } events;
  98
  99    Eina_Bool hide_by_request;
 100 };
 101
 102 static int _e_client_hooks_delete = 0;
 103 static int _e_client_hooks_walking = 0;
 104
 105 static int _e_client_intercept_hooks_delete = 0;
 106 static int _e_client_intercept_hooks_walking = 0;
 107
 108 E_API int E_EVENT_CLIENT_ADD = -1;
 109 E_API int E_EVENT_CLIENT_REMOVE = -1;
 110 E_API int E_EVENT_CLIENT_ZONE_SET = -1;
 111 E_API int E_EVENT_CLIENT_DESK_SET = -1;
 112 E_API int E_EVENT_CLIENT_RESIZE = -1;
 113 E_API int E_EVENT_CLIENT_MOVE = -1;
 114 E_API int E_EVENT_CLIENT_SHOW = -1;
 115 E_API int E_EVENT_CLIENT_HIDE = -1;
 116 E_API int E_EVENT_CLIENT_ICONIFY = -1;
 117 E_API int E_EVENT_CLIENT_UNICONIFY = -1;
 118 E_API int E_EVENT_CLIENT_STACK = -1;
 119 E_API int E_EVENT_CLIENT_FOCUS_IN = -1;
 120 E_API int E_EVENT_CLIENT_FOCUS_OUT = -1;
 121 E_API int E_EVENT_CLIENT_PROPERTY = -1;
 122 E_API int E_EVENT_CLIENT_FULLSCREEN = -1;
 123 E_API int E_EVENT_CLIENT_UNFULLSCREEN = -1;
 124 #ifdef _F_ZONE_WINDOW_ROTATION_
 125 E_API int E_EVENT_CLIENT_ROTATION_CHANGE_BEGIN = -1;
 126 E_API int E_EVENT_CLIENT_ROTATION_CHANGE_CANCEL = -1;
 127 E_API int E_EVENT_CLIENT_ROTATION_CHANGE_END = -1;
 128 E_API int E_EVENT_CLIENT_ROTATION_GEOMETRY_SET = -1;
 129 #endif
 130 E_API int E_EVENT_CLIENT_VISIBILITY_CHANGE = -1;
 131 E_API int E_EVENT_CLIENT_BUFFER_CHANGE = -1;
 132 E_API int E_EVENT_CLIENT_FOCUS_SKIP_SET = -1;
 133 E_API int E_EVENT_CLIENT_FOCUS_SKIP_UNSET = -1;
 134
 135 static Eina_Hash *clients_hash[E_PIXMAP_TYPE_MAX] = {NULL}; // pixmap->client
 136
 137 static E_Client *ecmove = NULL;
 138 static E_Client *ecresize = NULL;
 139 static E_Client *action_client = NULL;
 140
 141 static Eina_Bool comp_grabbed = EINA_FALSE;
 142
 143 static Eina_List *handlers = NULL;
 144 static Eina_List *hooks = NULL;
 145
 146 static Ecore_Event_Handler *action_handler_mouse = NULL;
 147 static Ecore_Timer *action_timer = NULL;
 148 static Eina_Rectangle action_orig = {0, 0, 0, 0};
 149
 150 static E_Client_Resize_Object_Create_Cb _e_client_resize_object_create_cb = NULL;
 151
 152 EINTERN void e_client_focused_set(E_Client *ec);
 153 static void _e_client_transient_for_group_make(E_Client *ec, Eina_List **list);
 154 static Evas_Object *_e_client_resize_object_create(E_Client *ec);
 155 static void _e_client_resize_object_del(E_Client *ec);
 156 static void _e_client_stay_within_canvas(E_Client *ec, int x, int y, int *new_x, int *new_y);
 157 static void _e_client_stay_within_canvas_margin(E_Client *ec, int x, int y, int *new_x, int *new_y);
 158
 159 static Eina_Inlist *_e_client_hooks[] =
 160 {
 161    [E_CLIENT_HOOK_EVAL_PRE_FETCH] = NULL,
 162    [E_CLIENT_HOOK_EVAL_FETCH] = NULL,
 163    [E_CLIENT_HOOK_EVAL_PRE_POST_FETCH] = NULL,
 164    [E_CLIENT_HOOK_EVAL_POST_FETCH] = NULL,
 165    [E_CLIENT_HOOK_EVAL_PRE_FRAME_ASSIGN] = NULL,
 166    [E_CLIENT_HOOK_EVAL_POST_FRAME_ASSIGN] = NULL,
 167    [E_CLIENT_HOOK_EVAL_PRE_NEW_CLIENT] = NULL,
 168    [E_CLIENT_HOOK_EVAL_POST_NEW_CLIENT] = NULL,
 169    [E_CLIENT_HOOK_EVAL_END] = NULL,
 170    [E_CLIENT_HOOK_FOCUS_SET] = NULL,
 171    [E_CLIENT_HOOK_FOCUS_UNSET] = NULL,
 172    [E_CLIENT_HOOK_NEW_CLIENT] = NULL,
 173    [E_CLIENT_HOOK_MOVE_BEGIN] = NULL,
 174    [E_CLIENT_HOOK_MOVE_UPDATE] = NULL,
 175    [E_CLIENT_HOOK_MOVE_END] = NULL,
 176    [E_CLIENT_HOOK_RESIZE_BEGIN] = NULL,
 177    [E_CLIENT_HOOK_RESIZE_UPDATE] = NULL,
 178    [E_CLIENT_HOOK_RESIZE_END] = NULL,
 179    [E_CLIENT_HOOK_FULLSCREEN_PRE] = NULL,
 180    [E_CLIENT_HOOK_DEL] = NULL,
 181    [E_CLIENT_HOOK_UNREDIRECT] = NULL,
 182    [E_CLIENT_HOOK_REDIRECT] = NULL,
 183 #ifdef _F_E_CLIENT_NEW_CLIENT_POST_HOOK_
 184    [E_CLIENT_HOOK_NEW_CLIENT_POST] = NULL,
 185 #endif
 186    [E_CLIENT_HOOK_EVAL_VISIBILITY] = NULL,
 187    [E_CLIENT_HOOK_ICONIFY] = NULL,
 188    [E_CLIENT_HOOK_UNICONIFY] = NULL,
 189    [E_CLIENT_HOOK_AUX_HINT_CHANGE] = NULL,
 190    [E_CLIENT_HOOK_WINDOW_ROLE_CHANGE] = NULL,
 191    [E_CLIENT_HOOK_TRANSFORM_CHANGE] = NULL,
 192    [E_CLIENT_HOOK_ACTIVATE_DONE] = NULL,
 193    [E_CLIENT_HOOK_EVAL_VISIBILITY_END] = NULL,
 194 };
 195
 196 static Eina_Inlist *_e_client_intercept_hooks[] =
 197 {
 198    [E_CLIENT_INTERCEPT_HOOK_FOCUS_REVERT] = NULL,
 199    [E_CLIENT_INTERCEPT_HOOK_AUTO_PLACEMENT] = NULL,
 200 };
 201
 202 ///////////////////////////////////////////
 203
 204 static void
 205 _e_client_hooks_clean(void)
 206 {
 207    Eina_Inlist *l;
 208    E_Client_Hook *ch;
 209    unsigned int x;
 210
 211    for (x = 0; x < E_CLIENT_HOOK_LAST; x++)
 212      EINA_INLIST_FOREACH_SAFE(_e_client_hooks[x], l, ch)
 213        {
 214           if (!ch->delete_me) continue;
 215           _e_client_hooks[x] = eina_inlist_remove(_e_client_hooks[x], EINA_INLIST_GET(ch));
 216           free(ch);
 217        }
 218 }
 219
 220 static Eina_Bool
 221 _e_client_hook_call(E_Client_Hook_Point hookpoint, E_Client *ec)
 222 {
 223    E_Client_Hook *ch;
 224
 225    e_object_ref(E_OBJECT(ec));
 226    _e_client_hooks_walking++;
 227    EINA_INLIST_FOREACH(_e_client_hooks[hookpoint], ch)
 228      {
 229         if (ch->delete_me) continue;
 230         ch->func(ch->data, ec);
 231         if ((hookpoint != E_CLIENT_HOOK_DEL) &&
 232           (hookpoint != E_CLIENT_HOOK_MOVE_END) &&
 233           (hookpoint != E_CLIENT_HOOK_RESIZE_END) &&
 234           (hookpoint != E_CLIENT_HOOK_FOCUS_UNSET) &&
 235           e_object_is_del(E_OBJECT(ec)))
 236           break;
 237      }
 238    _e_client_hooks_walking--;
 239    if ((_e_client_hooks_walking == 0) && (_e_client_hooks_delete > 0))
 240      _e_client_hooks_clean();
 241    return !!e_object_unref(E_OBJECT(ec));
 242 }
 243
 244 ///////////////////////////////////////////
 245
 246 static void
 247 _e_client_intercept_hooks_clean(void)
 248 {
 249    Eina_Inlist *l;
 250    E_Client_Intercept_Hook *ch;
 251    unsigned int x;
 252
 253    for (x = 0; x < E_CLIENT_INTERCEPT_HOOK_LAST; x++)
 254      EINA_INLIST_FOREACH_SAFE(_e_client_intercept_hooks[x], l, ch)
 255        {
 256           if (!ch->delete_me) continue;
 257           _e_client_intercept_hooks[x] =
 258              eina_inlist_remove(_e_client_intercept_hooks[x], EINA_INLIST_GET(ch));
 259           free(ch);
 260        }
 261 }
 262
 263 static Eina_Bool
 264 _e_client_intercept_hook_call(E_Client_Intercept_Hook_Point hookpoint, E_Client *ec)
 265 {
 266    E_Client_Intercept_Hook *ch;
 267    Eina_Bool ret = EINA_TRUE;
 268
 269    if (e_object_is_del(E_OBJECT(ec)))
 270      {
 271         if (hookpoint != E_CLIENT_INTERCEPT_HOOK_FOCUS_REVERT)
 272           {
 273              return ret;
 274           }
 275      }
 276
 277    e_object_ref(E_OBJECT(ec));
 278    _e_client_intercept_hooks_walking++;
 279    EINA_INLIST_FOREACH(_e_client_intercept_hooks[hookpoint], ch)
 280      {
 281         if (ch->delete_me) continue;
 282         if (!(ch->func(ch->data, ec)))
 283           {
 284              ret = EINA_FALSE;
 285              break;
 286           }
 287      }
 288    _e_client_intercept_hooks_walking--;
 289    if ((_e_client_intercept_hooks_walking == 0) &&
 290        (_e_client_intercept_hooks_delete > 0))
 291      _e_client_intercept_hooks_clean();
 292
 293    e_object_unref(E_OBJECT(ec));
 294    return ret;
 295 }
 296
 297 static void
 298 _e_client_event_simple_free(void *d EINA_UNUSED, E_Event_Client *ev)
 299 {
 300    UNREFD(ev->ec, 3);
 301    e_object_unref(E_OBJECT(ev->ec));
 302    free(ev);
 303 }
 304
 305 static void
 306 _e_client_event_simple(E_Client *ec, int type)
 307 {
 308    E_Event_Client *ev;
 309
 310    ev = E_NEW(E_Event_Client, 1);
 311    if (!ev) return;
 312    ev->ec = ec;
 313    REFD(ec, 3);
 314    e_object_ref(E_OBJECT(ec));
 315    ecore_event_add(type, ev, (Ecore_End_Cb)_e_client_event_simple_free, NULL);
 316 }
 317
 318 static void
 319 _e_client_event_add(E_Client *ec)
 320 {
 321    if (ec->reg_ev.add)
 322      return;
 323
 324    ec->reg_ev.add = EINA_TRUE;
 325    ELOGF("COMP", "SEND E_EVENT_CLIENT_ADD event", ec);
 326    _e_client_event_simple(ec, E_EVENT_CLIENT_ADD);
 327 }
 328
 329 static void
 330 _e_client_event_remove(E_Client *ec)
 331 {
 332    if (!ec->reg_ev.add)
 333      return;
 334
 335    ec->reg_ev.add = EINA_FALSE;
 336    ELOGF("COMP", "SEND E_EVENT_CLIENT_REMOVE event", ec);
 337    _e_client_event_simple(ec, E_EVENT_CLIENT_REMOVE);
 338 }
 339
 340 static void
 341 _e_client_event_show(E_Client *ec)
 342 {
 343    if (ec->reg_ev.show)
 344      return;
 345
 346    ec->reg_ev.show = EINA_TRUE;
 347    _e_client_event_simple(ec, E_EVENT_CLIENT_SHOW);
 348 }
 349
 350 static void
 351 _e_client_event_hide(E_Client *ec)
 352 {
 353    if (!ec->reg_ev.show)
 354      return;
 355
 356    ec->reg_ev.show = EINA_FALSE;
 357    _e_client_event_simple(ec, E_EVENT_CLIENT_HIDE);
 358 }
 359
 360 static void
 361 _e_client_event_property(E_Client *ec, int prop)
 362 {
 363    E_Event_Client_Property *ev;
 364
 365    ev = E_NEW(E_Event_Client_Property, 1);
 366    if (!ev) return;
 367    ev->ec = ec;
 368    ev->property = prop;
 369    REFD(ec, 33);
 370    e_object_ref(E_OBJECT(ec));
 371    ecore_event_add(E_EVENT_CLIENT_PROPERTY, ev, (Ecore_End_Cb)_e_client_event_simple_free, NULL);
 372 }
 373
 374 ////////////////////////////////////////////////
 375
 376 static int
 377 _e_client_action_input_win_del(void)
 378 {
 379    if (!comp_grabbed) return 0;
 380
 381    e_comp_ungrab_input(1, 1);
 382    comp_grabbed = 0;
 383    return 1;
 384 }
 385
 386 static void
 387 _e_client_action_finish(void)
 388 {
 389    if (comp_grabbed)
 390      _e_client_action_input_win_del();
 391
 392    E_FREE_FUNC(action_timer, ecore_timer_del);
 393    E_FREE_FUNC(action_handler_mouse, ecore_event_handler_del);
 394    if (action_client)
 395      {
 396         action_client->keyboard_resizing = 0;
 397      }
 398    action_client = NULL;
 399 }
 400
 401 static void
 402 _e_client_transform_point_transform(int cx, int cy, double angle, int x, int y, int *tx, int *ty)
 403 {
 404    double s = sin(angle * M_PI / 180);
 405    double c = cos(angle * M_PI / 180);
 406    int rx, ry;
 407
 408    x -= cx;
 409    y -= cy;
 410
 411    rx = x * c + y * s;
 412    ry = - x * s + y * c;
 413
 414    rx += cx;
 415    ry += cy;
 416
 417    *tx = rx;
 418    *ty = ry;
 419 }
 420
 421 static void
 422 _e_client_transform_geometry_save(E_Client *ec, E_Map *map)
 423 {
 424    int i;
 425
 426    if (!map) return;
 427
 428    for (i = 0; i < 4; i ++)
 429      {
 430         e_map_point_precise_coord_get(map, i,
 431                                       &ec->transform.saved[i].x,
 432                                       &ec->transform.saved[i].y,
 433                                       &ec->transform.saved[i].z);
 434      }
 435 }
 436
 437 static void
 438 _e_client_transform_resize(E_Client *ec)
 439 {
 440    E_Map *map;
 441    int cx, cy;
 442    double dx = 0, dy = 0;
 443    double px[4], py[4];
 444    int pw, ph;
 445    int i;
 446
 447    if (!ec->transformed) return;
 448
 449    if (!e_pixmap_size_get(ec->pixmap, &pw, &ph))
 450      {
 451         pw = ec->client.w;
 452         ph = ec->client.h;
 453      }
 454
 455    cx = ec->client.x + pw / 2;
 456    cy = ec->client.y + ph / 2;
 457
 458    /* step 1: Rotate resized object and get map points */
 459    map = e_map_new_with_direct_render(ec->transform_core.direct_render);
 460    e_map_util_points_populate_from_geometry(map,
 461                                             ec->client.x, ec->client.y,
 462                                             pw, ph,
 463                                             0);
 464    e_map_util_rotate(map, ec->transform.angle, cx, cy);
 465    e_map_util_zoom(map, ec->transform.zoom, ec->transform.zoom, cx, cy);
 466
 467    for (i = 0; i < 4; i++)
 468      e_map_point_precise_coord_get(map, i, &px[i], &py[i], NULL);
 469
 470    e_map_free(map);
 471
 472    /* step 2: get adjusted values to keep up fixed position according
 473     * to resize mode */
 474    switch (ec->resize_mode)
 475      {
 476       case E_POINTER_RESIZE_R:
 477       case E_POINTER_RESIZE_BR:
 478          dx = ec->transform.saved[0].x - px[0];
 479          dy = ec->transform.saved[0].y - py[0];
 480          break;
 481       case E_POINTER_RESIZE_BL:
 482       case E_POINTER_RESIZE_B:
 483          dx = ec->transform.saved[1].x - px[1];
 484          dy = ec->transform.saved[1].y - py[1];
 485          break;
 486       case E_POINTER_RESIZE_TL:
 487       case E_POINTER_RESIZE_L:
 488          dx = ec->transform.saved[2].x - px[2];
 489          dy = ec->transform.saved[2].y - py[2];
 490          break;
 491       case E_POINTER_RESIZE_T:
 492       case E_POINTER_RESIZE_TR:
 493          dx = ec->transform.saved[3].x - px[3];
 494          dy = ec->transform.saved[3].y - py[3];
 495          break;
 496       default:
 497          break;
 498      }
 499
 500    ec->transform.adjusted.x = dx;
 501    ec->transform.adjusted.y = dy;
 502
 503    /* step 3: set each points of the quadrangle */
 504    map = e_map_new_with_direct_render(ec->transform_core.direct_render);
 505    e_map_util_points_populate_from_object_full(map, ec->frame, 0);
 506
 507    for (i = 0; i < 4; i++)
 508       e_map_point_precise_coord_set(map, i, px[i] + dx, py[i] + dy, 0);
 509
 510    e_client_map_set(ec, map);
 511    e_client_map_enable_set(ec, EINA_TRUE);
 512    e_map_free(map);
 513 }
 514
 515 static void
 516 _e_client_transform_resize_handle(E_Client *ec)
 517 {
 518
 519    int new_x, new_y, new_w, new_h;
 520    int org_w, org_h;
 521    int button_id;
 522    int cx, cy;
 523    Evas_Point current, moveinfo;
 524    E_Zone *zone;
 525
 526    if (e_object_is_del(E_OBJECT(ec))) return;
 527    if (e_client_util_ignored_get(ec)) return;
 528    if (!ec->transformed) return;
 529
 530    zone = e_comp_zone_find_by_ec(ec);
 531    if (!zone) return;
 532
 533    button_id = ec->moveinfo.down.button;
 534
 535    org_w = ec->mouse.last_down[button_id - 1].w;
 536    org_h = ec->mouse.last_down[button_id - 1].h;
 537
 538    new_w = ec->client.w;
 539    new_h = ec->client.h;
 540    new_x = ec->client.x;
 541    new_y = ec->client.y;
 542
 543    /* step 1: get center coordinate its' based on original object geometry*/
 544    cx = ec->client.x + org_w / 2;
 545    cy = ec->client.y + org_h / 2;
 546
 547    /* step 2: transform coordinates of mouse position
 548     * subtract adjusted value from mouse position is needed */
 549    current.x = ec->mouse.current.mx - ec->transform.adjusted.x;
 550    current.y = ec->mouse.current.my - ec->transform.adjusted.y;
 551    moveinfo.x = ec->moveinfo.down.mx - ec->transform.adjusted.x;
 552    moveinfo.y = ec->moveinfo.down.my - ec->transform.adjusted.y;
 553
 554    _e_client_transform_point_transform(cx, cy, ec->transform.angle,
 555                                        current.x, current.y,
 556                                        &current.x, &current.y);
 557    _e_client_transform_point_transform(cx, cy, ec->transform.angle,
 558                                        moveinfo.x, moveinfo.y,
 559                                        &moveinfo.x, &moveinfo.y);
 560
 561    /* step 3: calculate new size */
 562    if ((ec->resize_mode == E_POINTER_RESIZE_TR) ||
 563        (ec->resize_mode == E_POINTER_RESIZE_R) ||
 564        (ec->resize_mode == E_POINTER_RESIZE_BR))
 565      {
 566         if ((button_id >= 1) && (button_id <= 3))
 567           new_w = org_w + (current.x - moveinfo.x);
 568         else
 569           new_w = ec->moveinfo.down.w + (current.x - moveinfo.x);
 570      }
 571    else if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
 572             (ec->resize_mode == E_POINTER_RESIZE_L) ||
 573             (ec->resize_mode == E_POINTER_RESIZE_BL))
 574      {
 575         if ((button_id >= 1) && (button_id <= 3))
 576           new_w = org_w - (current.x - moveinfo.x);
 577         else
 578           new_w = ec->moveinfo.down.w - (current.x - moveinfo.x);
 579      }
 580
 581    if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
 582        (ec->resize_mode == E_POINTER_RESIZE_T) ||
 583        (ec->resize_mode == E_POINTER_RESIZE_TR))
 584      {
 585         if ((button_id >= 1) && (button_id <= 3))
 586           new_h = org_h - (current.y - moveinfo.y);
 587         else
 588           new_h = ec->moveinfo.down.h - (current.y - moveinfo.y);
 589      }
 590    else if ((ec->resize_mode == E_POINTER_RESIZE_BL) ||
 591             (ec->resize_mode == E_POINTER_RESIZE_B) ||
 592             (ec->resize_mode == E_POINTER_RESIZE_BR))
 593      {
 594         if ((button_id >= 1) && (button_id <= 3))
 595           new_h = org_h + (current.y - moveinfo.y);
 596         else
 597           new_h = ec->moveinfo.down.h + (current.y - moveinfo.y);
 598      }
 599
 600    new_w = MIN(new_w, zone->w);
 601    new_h = MIN(new_h, zone->h);
 602
 603    /* step 4: move to new position */
 604    if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
 605        (ec->resize_mode == E_POINTER_RESIZE_L) ||
 606        (ec->resize_mode == E_POINTER_RESIZE_BL))
 607      new_x += (new_w - org_w);
 608    if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
 609        (ec->resize_mode == E_POINTER_RESIZE_T) ||
 610        (ec->resize_mode == E_POINTER_RESIZE_TR))
 611      new_y += (new_h - org_h);
 612
 613    /* step 5: set geometry to new value */
 614    evas_object_geometry_set(ec->frame, new_x, new_y, new_w, new_h);
 615 }
 616
 617 void
 618 _e_client_transform_resize_begin(E_Client *ec)
 619 {
 620    E_Map *map;
 621    if (!ec->transformed) return;
 622
 623    map = e_client_map_get(ec);
 624    _e_client_transform_geometry_save(ec, map);
 625    e_map_free(map);
 626 }
 627
 628 void
 629 _e_client_transform_resize_end(E_Client *ec)
 630 {
 631    E_Map *map;
 632    int new_x = 0, new_y = 0;
 633    int cx, cy, pw, ph;
 634
 635    if (!ec->transformed) return;
 636
 637    map = e_client_map_get(ec);
 638    if (!map) return;
 639
 640    if (!e_pixmap_size_get(ec->pixmap, &pw, &ph))
 641      {
 642         pw = ec->client.w;
 643         ph = ec->client.h;
 644      }
 645
 646    cx = ec->client.x + pw / 2 + ec->transform.adjusted.x;
 647    cy = ec->client.y + ph / 2 + ec->transform.adjusted.y;
 648
 649    if (ec->transform.zoom != 1.0)
 650      {
 651         E_Map *tmp_map;
 652
 653         tmp_map = e_map_dup(map);
 654         e_map_util_zoom(tmp_map,
 655                            1 / ec->transform.zoom,
 656                            1 / ec->transform.zoom,
 657                            cx, cy);
 658
 659         _e_client_transform_geometry_save(ec, tmp_map);
 660         e_map_free(tmp_map);
 661      }
 662    else
 663      {
 664         _e_client_transform_geometry_save(ec, map);
 665      }
 666
 667    /* move original object to adjusted position after resizing */
 668    _e_client_transform_point_transform(cx, cy,
 669                                        ec->transform.angle,
 670                                        ec->transform.saved[0].x,
 671                                        ec->transform.saved[0].y,
 672                                        &new_x, &new_y);
 673    e_client_util_move_without_frame(ec, new_x, new_y);
 674    e_map_util_object_move_sync_set(map, EINA_TRUE);
 675    e_map_free(map);
 676 }
 677
 678 static void
 679 _e_client_transform_move_end(E_Client *ec)
 680 {
 681
 682    int i;
 683    double dx, dy, px, py;
 684    E_Map *map;
 685
 686    if (!ec->transformed) return;
 687
 688    map = e_client_map_get(ec);
 689    if (!map) return;
 690
 691    if (ec->transform.zoom != 1.0)
 692      {
 693         e_map_point_precise_coord_get(map, 0, &px, &py, NULL);
 694
 695         dx = px - ec->transform.saved[0].x;
 696         dy = py - ec->transform.saved[0].y;
 697
 698         for (i = 0; i < 4; i++)
 699           {
 700              ec->transform.saved[i].x += dx;
 701              ec->transform.saved[i].y += dy;
 702           }
 703      }
 704    else
 705      _e_client_transform_geometry_save(ec, map);
 706    e_map_free(map);
 707 }
 708
 709 EINTERN Eina_Bool
 710 e_client_intercept_hook_focus_revert_call(E_Client *ec)
 711 {
 712   // no need to call the intercept hook if ec is NULL.
 713   if (!ec) return EINA_FALSE;
 714
 715   if (!_e_client_intercept_hook_call(E_CLIENT_INTERCEPT_HOOK_FOCUS_REVERT, ec))
 716     {
 717        ELOGF("FOCUS", "E_CLIENT_INTERCEPT_HOOK_FOCUS_REVERT Intercepted.", ec);
 718        return EINA_TRUE;
 719     }
 720
 721   return EINA_FALSE;
 722 }
 723
 724 EINTERN E_Client *
 725 e_client_check_fully_contain_by_above(E_Client *ec, Eina_Bool check_layer)
 726 {
 727    E_Client *above = NULL;
 728    E_Zone *zone = NULL;
 729    int x = 0, y = 0, w = 0, h = 0;
 730    int ax = 0, ay = 0, aw = 0, ah = 0;
 731
 732    if (!ec) return NULL;
 733
 734    e_client_geometry_get(ec, &x, &y, &w, &h);
 735
 736    zone = e_comp_zone_find_by_ec(ec);
 737    if (zone)
 738      E_RECTS_CLIP_TO_RECT(x, y, w, h, zone->x, zone->y, zone->w, zone->h);
 739
 740    above = e_client_above_get(ec);
 741    while (above)
 742      {
 743         if ((check_layer) &&
 744             (above->layer <= ec->layer))
 745           {
 746              above = e_client_above_get(above);
 747              continue;
 748           }
 749
 750         if ((!e_object_is_del(E_OBJECT(above))) &&
 751             (!e_client_util_ignored_get(above)) &&
 752             (above->visible) &&
 753             (!above->iconic || e_policy_visibility_client_is_uniconic(above)) &&
 754             (!above->bg_state) &&
 755             (!above->argb) &&
 756             (!above->visibility.force_obscured) &&
 757             (above->frame))
 758           {
 759              e_client_geometry_get(above, &ax, &ay, &aw, &ah);
 760              if (E_CONTAINS(ax, ay, aw, ah, x, y, w, h))
 761                break;
 762           }
 763         above = e_client_above_get(above);
 764      }
 765
 766    return above;
 767 }
 768
 769 EINTERN E_Client *
 770 e_client_check_obscured_by_children_group(E_Client *ec)
 771 {
 772    E_Client *cec = NULL;
 773    Eina_List *transients = NULL, *l = NULL;
 774
 775    _e_client_transient_for_group_make(ec, &transients);
 776    if (!transients) return NULL;
 777
 778    EINA_LIST_FOREACH(transients, l, cec)
 779      {
 780         if (E_CONTAINS(cec->x, cec->y, cec->w, cec->h, ec->x, ec->y, ec->w, ec->h))
 781           {
 782             if (!cec->argb) break;
 783             if (cec->visibility.opaque > 0) break;
 784           }
 785      }
 786
 787    eina_list_free(transients);
 788
 789    return cec;
 790 }
 791
 792 EINTERN Eina_Bool
 793 e_client_check_really_iconified(E_Client *ec)
 794 {
 795    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
 796
 797    if (!ec->iconic) return EINA_FALSE;
 798
 799    return ((!e_policy_visibility_client_is_uniconic(ec) &&
 800             !e_policy_visibility_client_is_uniconify_render_running(ec)) ||
 801            (e_client_is_iconified_by_client(ec)));
 802 }
 803
 804 static void
 805 _e_client_event_focus_skip_set(E_Client *ec, Eina_Bool by_client)
 806 {
 807    E_Event_Client_Focus_Skip_Set *ev;
 808
 809    ev = E_NEW(E_Event_Client_Focus_Skip_Set, 1);
 810    if (!ev) return;
 811
 812    ev->ec = ec;
 813    ev->by_client = by_client;
 814    e_object_ref(E_OBJECT(ec));
 815
 816    ecore_event_add(E_EVENT_CLIENT_FOCUS_SKIP_SET, ev, (Ecore_End_Cb)_e_client_event_simple_free, NULL);
 817 }
 818
 819 static void
 820 _e_client_event_focus_skip_unset(E_Client *ec, Eina_Bool by_client)
 821 {
 822    E_Event_Client_Focus_Skip_Unset *ev;
 823
 824    ev = E_NEW(E_Event_Client_Focus_Skip_Unset, 1);
 825    if (!ev) return;
 826
 827    ev->ec = ec;
 828    ev->by_client = by_client;
 829    e_object_ref(E_OBJECT(ec));
 830
 831    ecore_event_add(E_EVENT_CLIENT_FOCUS_SKIP_UNSET, ev, (Ecore_End_Cb)_e_client_event_simple_free, NULL);
 832 }
 833
 834 E_API void
 835 e_client_focus_skip_set(E_Client *ec, Eina_Bool skip, Eina_Bool by_client)
 836 {
 837    if (!ec) return;
 838
 839    if (skip)
 840      {
 841         if (ec->icccm.accepts_focus)
 842           {
 843              ELOGF("TZPOL", "FOCUS|SKIP SET (by_client:%d)", ec, by_client);
 844              ec->icccm.accepts_focus = ec->icccm.take_focus = 0;
 845              ec->changes.accepts_focus = 1;
 846              EC_CHANGED(ec);
 847
 848              _e_client_event_focus_skip_set(ec, by_client);
 849           }
 850      }
 851    else
 852      {
 853         if (!ec->icccm.accepts_focus)
 854           {
 855              ELOGF("TZPOL", "FOCUS|SKIP UNSET (by_client:%d)", ec, by_client);
 856              ec->icccm.accepts_focus = ec->icccm.take_focus = 1;
 857              ec->changes.accepts_focus = 1;
 858              EC_CHANGED(ec);
 859
 860              _e_client_event_focus_skip_unset(ec, by_client);
 861           }
 862      }
 863 }
 864
 865 EINTERN Eina_Bool
 866 e_client_check_above_focused(E_Client *ec)
 867 {
 868    E_Client *focus = NULL;
 869    E_Client *above = NULL;
 870
 871    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
 872
 873    focus = e_client_focused_get();
 874    if (!focus) return EINA_FALSE;
 875
 876    above = e_client_above_get(ec);
 877    while (above)
 878      {
 879         if (above == focus)
 880           return EINA_TRUE;
 881
 882         above = e_client_above_get(above);
 883      }
 884
 885    return EINA_FALSE;
 886 }
 887
 888 static Eina_Bool
 889 _e_client_private_init(E_Client *ec)
 890 {
 891    E_Client_Private *priv;
 892
 893    priv = E_NEW(E_Client_Private, 1);
 894    if (!priv)
 895      return EINA_FALSE;
 896
 897    wl_signal_init(&priv->events.eval_pre_fetch);
 898    wl_signal_init(&priv->events.eval_fetch);
 899    wl_signal_init(&priv->events.eval_pre_post_fetch);
 900    wl_signal_init(&priv->events.eval_post_fetch);
 901    wl_signal_init(&priv->events.eval_pre_frame_assign);
 902    wl_signal_init(&priv->events.eval_post_frame_assign);
 903    wl_signal_init(&priv->events.eval_pre_new_client);
 904    wl_signal_init(&priv->events.eval_post_new_client);
 905    wl_signal_init(&priv->events.eval_visibility);
 906    wl_signal_init(&priv->events.eval_visibility_end);
 907    wl_signal_init(&priv->events.eval_end);
 908    wl_signal_init(&priv->events.move_begin);
 909    wl_signal_init(&priv->events.move_update);
 910    wl_signal_init(&priv->events.move_end);
 911    wl_signal_init(&priv->events.move_resize_begin);
 912    wl_signal_init(&priv->events.move_resize_update);
 913    wl_signal_init(&priv->events.move_resize_end);
 914    wl_signal_init(&priv->events.destroy);
 915    wl_signal_init(&priv->events.new_client);
 916    wl_signal_init(&priv->events.new_client_post);
 917    wl_signal_init(&priv->events.unredirect);
 918    wl_signal_init(&priv->events.redirect);
 919    wl_signal_init(&priv->events.aux_hint_change);
 920    wl_signal_init(&priv->events.window_role_change);
 921    wl_signal_init(&priv->events.transform_change);
 922    wl_signal_init(&priv->events.activate_done);
 923    wl_signal_init(&priv->events.mouse_in);
 924    wl_signal_init(&priv->events.mouse_out);
 925    wl_signal_init(&priv->events.mouse_down);
 926    wl_signal_init(&priv->events.focus_set);
 927    wl_signal_init(&priv->events.focus_unset);
 928    wl_signal_init(&priv->events.focus_defer_set);
 929    wl_signal_init(&priv->events.focus_latest_set);
 930    wl_signal_init(&priv->events.iconify);
 931    wl_signal_init(&priv->events.uniconify);
 932    wl_signal_init(&priv->events.maximize);
 933    wl_signal_init(&priv->events.unmaximize);
 934    wl_signal_init(&priv->events.fullscreen_pre);
 935    wl_signal_init(&priv->events.fullscreen);
 936    wl_signal_init(&priv->events.unfullscreen);
 937    wl_signal_init(&priv->events.move);
 938    wl_signal_init(&priv->events.set_layer);
 939    wl_signal_init(&priv->events.raise);
 940    wl_signal_init(&priv->events.lower);
 941    wl_signal_init(&priv->events.stack_below);
 942    wl_signal_init(&priv->events.stack_above);
 943    wl_signal_init(&priv->events.stack_transient_for_done);
 944    wl_signal_init(&priv->events.stick);
 945    wl_signal_init(&priv->events.unstick);
 946 #ifdef REFACTOR_DESK_AREA
 947    wl_signal_init(&priv->events.get_above);
 948    wl_signal_init(&priv->events.get_below);
 949    wl_signal_init(&priv->events.get_visible_above);
 950    wl_signal_init(&priv->events.get_visible_below);
 951    wl_signal_init(&priv->events.subsurface_stack_update);
 952 #endif
 953
 954    e_object_data_set(E_OBJECT(ec), priv);
 955
 956    return EINA_TRUE;
 957 }
 958
 959 static void
 960 _e_client_private_finish(E_Client *ec)
 961 {
 962    E_Client_Private *priv;
 963
 964    priv = PRI(ec);
 965    e_object_data_set(E_OBJECT(ec), NULL);
 966
 967    free(priv);
 968 }
 969
 970 static void
 971 _e_client_free(E_Client *ec)
 972 {
 973    g_rec_mutex_lock(&e_comp->ec_list_mutex);
 974
 975    e_comp_object_redirected_set(ec->frame, 0);
 976    e_comp_object_render_update_del(ec->frame);
 977
 978    E_OBJECT(ec)->references++;
 979
 980    if (ec->new_client)
 981      e_comp->new_clients--;
 982
 983    if (ec->e.state.video_parent && ec->e.state.video_parent_client)
 984      {
 985         ec->e.state.video_parent_client->e.state.video_child =
 986           eina_list_remove(ec->e.state.video_parent_client->e.state.video_child, ec);
 987      }
 988    if (ec->e.state.video_child)
 989      {
 990         E_Client *tmp;
 991
 992         EINA_LIST_FREE(ec->e.state.video_child, tmp)
 993           tmp->e.state.video_parent_client = NULL;
 994      }
 995    E_FREE_FUNC(ec->kill_timer, ecore_timer_del);
 996
 997    E_FREE_FUNC(ec->map_timer, ecore_timer_del);
 998
 999    ec->transients = eina_list_free(ec->transients);
1000    eina_stringshare_replace(&ec->border.name, NULL);
1001    eina_stringshare_replace(&ec->bordername, NULL);
1002    eina_stringshare_replace(&ec->icccm.name, NULL);
1003 #if defined(__cplusplus) || defined(c_plusplus)
1004    eina_stringshare_replace(&ec->icccm.cpp_class, NULL);
1005 #else
1006    eina_stringshare_replace(&ec->icccm.class, NULL);
1007 #endif
1008    eina_stringshare_replace(&ec->icccm.title, NULL);
1009    eina_stringshare_replace(&ec->icccm.window_role, NULL);
1010    eina_stringshare_replace(&ec->netwm.name, NULL);
1011
1012    E_FREE_FUNC(ec->frame, evas_object_del);
1013
1014    E_OBJECT(ec)->references--;
1015    ELOGF("COMP", "CLIENT FREE", ec);
1016
1017    e_uuid_store_entry_del(ec->uuid);
1018
1019    _e_client_private_finish(ec);
1020    free(ec);
1021
1022    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
1023 }
1024
1025 static void
1026 _e_client_del(E_Client *ec)
1027 {
1028    E_Client *child;
1029    E_Pixmap_Type type;
1030
1031    g_rec_mutex_lock(&e_comp->ec_list_mutex);
1032
1033    ec->changed = 0;
1034
1035    if (ec == e_comp_object_dim_client_get())
1036      {
1037         INF("[DIM] client deleted\n");
1038         e_comp_object_dim_client_set(NULL);
1039      }
1040
1041    if (ec->cur_mouse_action)
1042      {
1043         if (ec->cur_mouse_action->func.end)
1044           ec->cur_mouse_action->func.end(E_OBJECT(ec), "");
1045      }
1046    if (action_client == ec) _e_client_action_finish();
1047
1048    if (!stopping)
1049      {
1050         e_client_comp_hidden_set(ec, 1);
1051         evas_object_pass_events_set(ec->frame, 1);
1052      }
1053
1054    E_FREE_FUNC(ec->ping_poller, ecore_poller_del);
1055
1056    wl_signal_emit_mutable(&PRI(ec)->events.destroy, NULL);
1057
1058    /* must be called before parent/child clear */
1059    _e_client_hook_call(E_CLIENT_HOOK_DEL, ec);
1060
1061    _e_client_event_remove(ec);
1062
1063    ELOGF("COMP", "CLIENT DEL", ec);
1064
1065    if (ec->parent)
1066      {
1067         ec->parent->transients = eina_list_remove(ec->parent->transients, ec);
1068         ec->parent = NULL;
1069      }
1070    EINA_LIST_FREE(ec->transients, child)
1071      child->parent = NULL;
1072
1073    type = e_pixmap_type_get(ec->pixmap);
1074    if (type < E_PIXMAP_TYPE_MAX)
1075      eina_hash_del_by_key(clients_hash[type], &ec->pixmap);
1076    e_comp->clients = eina_list_remove(e_comp->clients, ec);
1077    e_comp_object_render_update_del(ec->frame);
1078    e_comp_post_update_purge(ec);
1079    if (e_pixmap_free(ec->pixmap))
1080      e_pixmap_client_set(ec->pixmap, NULL);
1081    ec->pixmap = NULL;
1082
1083    // base_output_resolution
1084    e_util_transform_del(ec->base_output_resolution.transform);
1085    ec->base_output_resolution.transform = NULL;
1086    E_FREE_FUNC(ec->base_output_resolution.hook_subsurf_create, e_comp_wl_hook_del);
1087
1088    if (ec->transform_core.transform_list)
1089      {
1090         E_Util_Transform *transform;
1091
1092         EINA_LIST_FREE(ec->transform_core.transform_list, transform)
1093           {
1094              e_util_transform_unref(transform);
1095           }
1096      }
1097
1098    ec->transform_core.result.enable = EINA_FALSE;
1099
1100    _e_client_resize_object_del(ec);
1101
1102    e_comp_visibility_calculation_set(EINA_TRUE);
1103
1104    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
1105 }
1106
1107 ///////////////////////////////////////////
1108
1109 static Eina_Bool
1110 _e_client_cb_kill_timer(void *data)
1111 {
1112    E_Client *ec = data;
1113
1114 // dont wait until it's hung -
1115 //   if (ec->hung)
1116 //     {
1117    if (ec->netwm.pid > 1)
1118      kill(ec->netwm.pid, SIGKILL);
1119 //     }
1120    ec->kill_timer = NULL;
1121    return ECORE_CALLBACK_CANCEL;
1122 }
1123
1124 static Eina_Bool
1125 _e_client_cb_ping_poller(void *data)
1126 {
1127    E_Client *ec;
1128
1129    ec = data;
1130    if (e_object_is_del(E_OBJECT(ec)))
1131      {
1132         ec->ping_poller = NULL;
1133         return ECORE_CALLBACK_CANCEL;
1134      }
1135
1136    if (ec->ping_ok)
1137      {
1138         if (ec->hung)
1139           {
1140              ec->hung = 0;
1141              evas_object_smart_callback_call(ec->frame, "unhung", NULL);
1142              E_FREE_FUNC(ec->kill_timer, ecore_timer_del);
1143           }
1144      }
1145    else
1146      {
1147         /* if time between last ping and now is greater
1148          * than half the ping interval... */
1149         if ((ecore_loop_time_get() - ec->ping) >
1150             ((e_config->ping_clients_interval *
1151               ecore_poller_poll_interval_get(ECORE_POLLER_CORE)) / 2.0))
1152           {
1153              if (!ec->hung)
1154                {
1155                   ec->hung = 1;
1156                   evas_object_smart_callback_call(ec->frame, "hung", NULL);
1157                   /* FIXME: if below dialog is up - hide it now */
1158                }
1159              if (ec->delete_requested)
1160                {
1161                   /* FIXME: pop up dialog saying app is hung - kill client, or pid */
1162                   e_client_act_kill_begin(ec);
1163                }
1164           }
1165      }
1166    ec->ping_poller = NULL;
1167    e_client_ping(ec);
1168    return ECORE_CALLBACK_CANCEL;
1169 }
1170
1171 ///////////////////////////////////////////
1172
1173 static int
1174 _e_client_action_input_win_new(void)
1175 {
1176    if (comp_grabbed)
1177      {
1178         CRI("DOUBLE COMP GRAB! ACK!!!!");
1179         return 1;
1180      }
1181    comp_grabbed = e_comp_grab_input(1, 1);
1182    if (!comp_grabbed) _e_client_action_input_win_del();
1183    return comp_grabbed;
1184 }
1185
1186 static void
1187 _e_client_action_init(E_Client *ec)
1188 {
1189    action_orig.x = ec->x;
1190    action_orig.y = ec->y;
1191    action_orig.w = ec->w;
1192    action_orig.h = ec->h;
1193
1194    if (action_client)
1195      {
1196         action_client->keyboard_resizing = 0;
1197      }
1198    action_client = ec;
1199 }
1200
1201 static int
1202 _e_client_move_begin(E_Client *ec)
1203 {
1204    if ((ec->fullscreen) || (ec->lock_user_location))
1205      return 0;
1206
1207    if (!_e_client_action_input_win_new()) return 0;
1208    ec->moving = 1;
1209    ecmove = ec;
1210
1211    wl_signal_emit_mutable(&PRI(ec)->events.move_begin, NULL);
1212    _e_client_hook_call(E_CLIENT_HOOK_MOVE_BEGIN, ec);
1213    if (!ec->moving)
1214      {
1215         if (ecmove == ec) ecmove = NULL;
1216         _e_client_action_input_win_del();
1217         return 0;
1218      }
1219    if (!ec->lock_user_stacking)
1220      {
1221         if (e_config->border_raise_on_mouse_action)
1222           e_client_raise(ec);
1223      }
1224
1225    if (e_comp->hwc)
1226      e_comp_client_override_add(ec);
1227
1228    return 1;
1229 }
1230
1231 static int
1232 _e_client_move_end(E_Client *ec)
1233 {
1234    ec->moving = 0;
1235    _e_client_action_input_win_del();
1236
1237    wl_signal_emit_mutable(&PRI(ec)->events.move_end, NULL);
1238    _e_client_hook_call(E_CLIENT_HOOK_MOVE_END, ec);
1239
1240    if (ec->transformed)
1241      _e_client_transform_move_end(ec);
1242
1243    if (e_comp->hwc)
1244      e_comp_client_override_del(ec);
1245
1246    ecmove = NULL;
1247    return 1;
1248 }
1249
1250 static Eina_Bool
1251 _e_client_action_move_timeout(void *data EINA_UNUSED)
1252 {
1253    _e_client_move_end(action_client);
1254    _e_client_action_finish();
1255    return ECORE_CALLBACK_CANCEL;
1256 }
1257
1258 static void
1259 _e_client_action_move_timeout_add(void)
1260 {
1261    E_FREE_FUNC(action_timer, ecore_timer_del);
1262    if (e_config->border_keyboard.timeout)
1263      action_timer = ecore_timer_add(e_config->border_keyboard.timeout, _e_client_action_move_timeout, NULL);
1264 }
1265
1266 static Eina_Bool
1267 _e_client_move_mouse_down(void *data EINA_UNUSED, int type EINA_UNUSED, void *event EINA_UNUSED)
1268 {
1269    if (!comp_grabbed) return ECORE_CALLBACK_RENEW;
1270
1271    if (!action_client)
1272      ERR("no action_client!");
1273
1274    if (action_client) _e_client_move_end(action_client);
1275    _e_client_action_finish();
1276    return ECORE_CALLBACK_DONE;
1277 }
1278
1279 static void
1280 _e_client_moveinfo_gather(E_Client *ec, const char *source)
1281 {
1282    if (e_util_glob_match(source, "mouse,*,1"))
1283      ec->moveinfo.down.button = 1;
1284    else if (e_util_glob_match(source, "mouse,*,2"))
1285      ec->moveinfo.down.button = 2;
1286    else if (e_util_glob_match(source, "mouse,*,3"))
1287      ec->moveinfo.down.button = 3;
1288    else
1289      ec->moveinfo.down.button = 0;
1290    if ((ec->moveinfo.down.button >= 1) && (ec->moveinfo.down.button <= 3))
1291      {
1292         ec->moveinfo.down.mx = ec->mouse.last_down[ec->moveinfo.down.button - 1].mx;
1293         ec->moveinfo.down.my = ec->mouse.last_down[ec->moveinfo.down.button - 1].my;
1294      }
1295    else
1296      {
1297         ec->moveinfo.down.mx = ec->mouse.current.mx;
1298         ec->moveinfo.down.my = ec->mouse.current.my;
1299      }
1300 }
1301
1302 static void
1303 _e_client_move_handle(E_Client *ec)
1304 {
1305    int x, y;
1306
1307    if ((ec->moveinfo.down.button >= 1) && (ec->moveinfo.down.button <= 3))
1308      {
1309         x = ec->mouse.last_down[ec->moveinfo.down.button - 1].x +
1310            (ec->mouse.current.mx - ec->moveinfo.down.mx);
1311         y = ec->mouse.last_down[ec->moveinfo.down.button - 1].y +
1312            (ec->mouse.current.my - ec->moveinfo.down.my);
1313      }
1314    else
1315      {
1316         x = ec->moveinfo.down.x +
1317            (ec->mouse.current.mx - ec->moveinfo.down.mx);
1318         y = ec->moveinfo.down.y +
1319            (ec->mouse.current.my - ec->moveinfo.down.my);
1320      }
1321
1322    if (e_config->screen_limits == E_CLIENT_OFFSCREEN_LIMIT_ALLOW_NONE)
1323      _e_client_stay_within_canvas(ec, x, y, &x, &y);
1324
1325    if (ec->floating)
1326      _e_client_stay_within_canvas_margin(ec, x, y, &x, &y);
1327
1328    evas_object_move(ec->frame, x, y);
1329
1330    if (e_client_transform_core_enable_get(ec))
1331      {
1332         e_client_transform_core_update(ec);
1333      }
1334 }
1335
1336 static Evas_Object *
1337 _e_client_resize_object_rectangle_get(E_Client *ec)
1338 {
1339    Evas_Object *resize_obj = NULL;
1340
1341    resize_obj = evas_object_rectangle_add(evas_object_evas_get(ec->frame));
1342    EINA_SAFETY_ON_NULL_RETURN_VAL(resize_obj, NULL);
1343
1344    if (e_config->resize_object.customize)
1345      {
1346         evas_object_color_set(resize_obj,
1347                               e_config->resize_object.r,
1348                               e_config->resize_object.g,
1349                               e_config->resize_object.b,
1350                               e_config->resize_object.a);
1351      }
1352    else
1353      evas_object_color_set(resize_obj, 128, 128, 128, 100);
1354
1355    return resize_obj;
1356 }
1357
1358 static Evas_Object *
1359 _e_client_resize_object_image_get(E_Client *ec)
1360 {
1361    int err;
1362    Evas_Object *resize_obj = NULL;
1363
1364    if (!e_config->resize_object.image_path)
1365      {
1366         ELOGF("COMP", "NO resize_object image! Make default resize_object", ec);
1367         goto get_rectangle;
1368      }
1369
1370    resize_obj = evas_object_image_add(evas_object_evas_get(ec->frame));
1371    EINA_SAFETY_ON_NULL_RETURN_VAL(resize_obj, NULL);
1372
1373    evas_object_image_file_set(resize_obj, e_config->resize_object.image_path, NULL);
1374    err = evas_object_image_load_error_get(resize_obj);
1375    if (err != EVAS_LOAD_ERROR_NONE)
1376      {
1377         ELOGF("COMP", "Image load error. path:%s, errno:%d. Make default resize_object",
1378               ec, e_config->resize_object.image_path, err);
1379         evas_object_del(resize_obj);
1380         resize_obj = NULL;
1381         goto get_rectangle;
1382      }
1383
1384    evas_object_image_fill_set(resize_obj, 0, 0, ec->w, ec->h);
1385    evas_object_image_filled_set(resize_obj, EINA_TRUE);
1386
1387    evas_object_image_border_set(resize_obj,
1388                                 e_config->resize_object.border_width.l,
1389                                 e_config->resize_object.border_width.r,
1390                                 e_config->resize_object.border_width.t,
1391                                 e_config->resize_object.border_width.b);
1392
1393    return resize_obj;
1394
1395 get_rectangle:
1396    return _e_client_resize_object_rectangle_get(ec);
1397 }
1398
1399 static Evas_Object *
1400 _e_client_resize_object_create(E_Client *ec)
1401 {
1402    EINA_SAFETY_ON_NULL_RETURN_VAL(ec->frame, NULL);
1403
1404    Evas_Object *resize_obj = NULL;
1405
1406    if (_e_client_resize_object_create_cb)
1407      resize_obj = _e_client_resize_object_create_cb(ec);
1408    else
1409      {
1410         if (e_config->resize_object.type == 1) // image object
1411           {
1412              resize_obj = _e_client_resize_object_image_get(ec);
1413           }
1414         else // rectangle
1415           {
1416              resize_obj = _e_client_resize_object_rectangle_get(ec);
1417           }
1418      }
1419    EINA_SAFETY_ON_NULL_RETURN_VAL(resize_obj, NULL);
1420
1421    evas_object_pass_events_set(resize_obj, EINA_TRUE);
1422    evas_object_layer_set(resize_obj, evas_object_layer_get(ec->frame));
1423    evas_object_stack_above(resize_obj, ec->frame);
1424    evas_object_name_set(resize_obj, "resize_object");
1425
1426    return resize_obj;
1427 }
1428
1429 static void
1430 _e_client_resize_object_del(E_Client *ec)
1431 {
1432    if (ec == NULL) return;
1433    if (ec->manage_resize.resize_obj == NULL) return;
1434
1435    evas_object_hide(ec->manage_resize.resize_obj);
1436    evas_object_del(ec->manage_resize.resize_obj);
1437    ec->manage_resize.resize_obj = NULL;
1438 }
1439
1440 static void
1441 _e_client_resize_handle(E_Client *ec)
1442 {
1443    int x, y, w, h;
1444    int new_x, new_y, new_w, new_h;
1445    int tw, th;
1446    int trans_x = 0, trans_y = 0;
1447    int trans_w = 0, trans_h = 0;
1448
1449    if (ec->transformed)
1450      {
1451         _e_client_transform_resize_handle(ec);
1452         return;
1453      }
1454
1455    x = ec->x;
1456    y = ec->y;
1457    w = ec->w;
1458    h = ec->h;
1459
1460    if ((ec->resize_mode == E_POINTER_RESIZE_TR) ||
1461        (ec->resize_mode == E_POINTER_RESIZE_R) ||
1462        (ec->resize_mode == E_POINTER_RESIZE_BR))
1463      {
1464         if ((ec->moveinfo.down.button >= 1) &&
1465             (ec->moveinfo.down.button <= 3))
1466           w = ec->mouse.last_down[ec->moveinfo.down.button - 1].w +
1467             (ec->mouse.current.mx - ec->moveinfo.down.mx);
1468         else
1469           w = ec->moveinfo.down.w + (ec->mouse.current.mx - ec->moveinfo.down.mx);
1470      }
1471    else if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
1472             (ec->resize_mode == E_POINTER_RESIZE_L) ||
1473             (ec->resize_mode == E_POINTER_RESIZE_BL))
1474      {
1475         if ((ec->moveinfo.down.button >= 1) &&
1476             (ec->moveinfo.down.button <= 3))
1477           w = ec->mouse.last_down[ec->moveinfo.down.button - 1].w -
1478             (ec->mouse.current.mx - ec->moveinfo.down.mx);
1479         else
1480           w = ec->moveinfo.down.w - (ec->mouse.current.mx - ec->moveinfo.down.mx);
1481      }
1482
1483    if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
1484        (ec->resize_mode == E_POINTER_RESIZE_T) ||
1485        (ec->resize_mode == E_POINTER_RESIZE_TR))
1486      {
1487         if ((ec->moveinfo.down.button >= 1) &&
1488             (ec->moveinfo.down.button <= 3))
1489           h = ec->mouse.last_down[ec->moveinfo.down.button - 1].h -
1490             (ec->mouse.current.my - ec->moveinfo.down.my);
1491         else
1492           h = ec->moveinfo.down.h - (ec->mouse.current.my - ec->moveinfo.down.my);
1493      }
1494    else if ((ec->resize_mode == E_POINTER_RESIZE_BL) ||
1495             (ec->resize_mode == E_POINTER_RESIZE_B) ||
1496             (ec->resize_mode == E_POINTER_RESIZE_BR))
1497      {
1498         if ((ec->moveinfo.down.button >= 1) &&
1499             (ec->moveinfo.down.button <= 3))
1500           h = ec->mouse.last_down[ec->moveinfo.down.button - 1].h +
1501             (ec->mouse.current.my - ec->moveinfo.down.my);
1502         else
1503           h = ec->moveinfo.down.h + (ec->mouse.current.my - ec->moveinfo.down.my);
1504      }
1505    tw = ec->w;
1506    th = ec->h;
1507
1508    if ((ec->resize_mode == E_POINTER_RESIZE_T) ||
1509        (ec->resize_mode == E_POINTER_RESIZE_TL) ||
1510        (ec->resize_mode == E_POINTER_RESIZE_L) ||
1511        (ec->resize_mode == E_POINTER_RESIZE_BL))
1512      x += (tw - w);
1513    if ((ec->resize_mode == E_POINTER_RESIZE_L) ||
1514        (ec->resize_mode == E_POINTER_RESIZE_TL) ||
1515        (ec->resize_mode == E_POINTER_RESIZE_T) ||
1516        (ec->resize_mode == E_POINTER_RESIZE_TR))
1517      y += (th - h);
1518
1519    new_x = x;
1520    new_y = y;
1521    new_w = w;
1522    new_h = h;
1523    if (e_config->screen_limits == E_CLIENT_OFFSCREEN_LIMIT_ALLOW_NONE)
1524      {
1525         E_Zone *zone;
1526         zone = e_comp_zone_find_by_ec(ec);
1527         if (zone)
1528           {
1529              w = MIN(w, zone->w);
1530              h = MIN(h, zone->h);
1531           }
1532      }
1533    e_client_resize_limit(ec, &new_w, &new_h);
1534
1535    if (ec->manage_resize.enable_aspect_ratio)
1536      {
1537         if ((ec->resize_mode == E_POINTER_RESIZE_TL) ||
1538             (ec->resize_mode == E_POINTER_RESIZE_L) ||
1539             (ec->resize_mode == E_POINTER_RESIZE_BL) ||
1540             (ec->resize_mode == E_POINTER_RESIZE_TR) ||
1541             (ec->resize_mode == E_POINTER_RESIZE_R) ||
1542             (ec->resize_mode == E_POINTER_RESIZE_BR))
1543           {
1544              new_h = (int) ec->manage_resize.ah / ec->manage_resize.aw * new_w;
1545           }
1546         else if ((ec->resize_mode == E_POINTER_RESIZE_T) ||
1547                  (ec->resize_mode == E_POINTER_RESIZE_B))
1548           {
1549              new_w = (int) ec->manage_resize.aw / ec->manage_resize.ah * new_h;
1550           }
1551           new_h += ec->manage_resize.header_h;
1552           new_h += ec->manage_resize.footer_h;
1553      }
1554
1555    if ((ec->resize_mode == E_POINTER_RESIZE_T) ||
1556        (ec->resize_mode == E_POINTER_RESIZE_TL) ||
1557        (ec->resize_mode == E_POINTER_RESIZE_L) ||
1558        (ec->resize_mode == E_POINTER_RESIZE_BL))
1559      new_x += (w - new_w);
1560    if ((ec->resize_mode == E_POINTER_RESIZE_L) ||
1561        (ec->resize_mode == E_POINTER_RESIZE_TL) ||
1562        (ec->resize_mode == E_POINTER_RESIZE_T) ||
1563        (ec->resize_mode == E_POINTER_RESIZE_TR))
1564      new_y += (h - new_h);
1565
1566    if (e_config->interactive_resize)
1567      {
1568         evas_object_geometry_set(ec->frame, new_x, new_y, new_w, new_h);
1569      }
1570    else
1571      {
1572         if (ec->manage_resize.resize_obj == NULL)
1573           {
1574              ec->manage_resize.resize_obj = _e_client_resize_object_create(ec);
1575              EINA_SAFETY_ON_NULL_RETURN(ec->manage_resize.resize_obj);
1576           }
1577
1578         if (e_client_transform_core_enable_get(ec))
1579           {
1580              e_client_transform_core_input_inv_transform(ec, new_x, new_y, &trans_x, &trans_y);
1581              e_client_transform_core_input_inv_transform(ec, new_w, new_h, &trans_w, &trans_h);
1582              evas_object_geometry_set(ec->manage_resize.resize_obj, trans_x, trans_y, trans_w, trans_h);
1583           }
1584         else
1585           evas_object_geometry_set(ec->manage_resize.resize_obj, new_x, new_y, new_w, new_h);
1586         evas_object_show(ec->manage_resize.resize_obj);
1587
1588         ec->manage_resize.x = new_x;
1589         ec->manage_resize.y = new_y;
1590         ec->manage_resize.w = new_w;
1591         ec->manage_resize.h = new_h;
1592      }
1593 }
1594
1595 static int
1596 _e_client_adjust_size_by_ppu(int size, int start_size, unsigned int ppu)
1597 {
1598    if (ppu <= 1) return size;
1599
1600    unsigned int remainder = size % ppu;
1601    if (remainder == 0) return size;
1602
1603    int gap = size - start_size;
1604    int new_size = size;
1605    if (gap > 0)
1606      new_size = size + (ppu - remainder);
1607    else
1608      new_size = size - remainder;
1609
1610    return new_size;
1611 }
1612
1613 static int
1614 _e_client_adjust_position_by_ppu(int pos, int size, int prev_pos, int prev_size)
1615 {
1616    int new_pos = 0;
1617
1618    if (prev_pos == pos)
1619      new_pos = pos;
1620    else
1621      new_pos = (prev_pos + prev_size) - size;
1622
1623    return new_pos;
1624 }
1625
1626 static void
1627 _e_client_adjust_geometry_by_resize_ppu(E_Client *ec)
1628 {
1629    if (ec->manage_resize.unit_size <= 1) return;
1630
1631    ec->manage_resize.w = _e_client_adjust_size_by_ppu(ec->manage_resize.w, ec->w, ec->manage_resize.unit_size);
1632    ec->manage_resize.h = _e_client_adjust_size_by_ppu(ec->manage_resize.h, ec->h, ec->manage_resize.unit_size);
1633
1634    ec->manage_resize.x = _e_client_adjust_position_by_ppu(ec->manage_resize.x, ec->manage_resize.w, ec->x, ec->w);
1635    ec->manage_resize.y = _e_client_adjust_position_by_ppu(ec->manage_resize.y, ec->manage_resize.h, ec->y, ec->h);
1636 }
1637
1638 static int
1639 _e_client_resize_end(E_Client *ec)
1640 {
1641    ec->resize_mode = E_POINTER_RESIZE_NONE;
1642    _e_client_action_input_win_del();
1643
1644    wl_signal_emit_mutable(&PRI(ec)->events.move_resize_end, NULL);
1645    _e_client_hook_call(E_CLIENT_HOOK_RESIZE_END, ec);
1646
1647    if (ec->transformed)
1648      _e_client_transform_resize_end(ec);
1649
1650    if (e_comp->hwc)
1651      e_comp_client_override_del(ec);
1652
1653    ecresize = NULL;
1654
1655    if (!e_config->interactive_resize)
1656      {
1657         if (ec->manage_resize.resize_obj)
1658           {
1659              if (ec->manage_resize.unit_size > 1)
1660                _e_client_adjust_geometry_by_resize_ppu(ec);
1661
1662              e_client_frame_geometry_set(ec,
1663                                          ec->manage_resize.x,
1664                                          ec->manage_resize.y,
1665                                          ec->manage_resize.w,
1666                                          ec->manage_resize.h);
1667              _e_client_resize_object_del(ec);
1668           }
1669      }
1670
1671    return 1;
1672 }
1673
1674 static Eina_Bool
1675 _e_client_action_resize_timeout(void *data EINA_UNUSED)
1676 {
1677    _e_client_resize_end(action_client);
1678    _e_client_action_finish();
1679    return ECORE_CALLBACK_CANCEL;
1680 }
1681
1682 static void
1683 _e_client_action_resize_timeout_add(void)
1684 {
1685    E_FREE_FUNC(action_timer, ecore_timer_del);
1686    if (e_config->border_keyboard.timeout)
1687      action_timer = ecore_timer_add(e_config->border_keyboard.timeout, _e_client_action_resize_timeout, NULL);
1688 }
1689
1690 static Eina_Bool
1691 _e_client_resize_mouse_down(void *data EINA_UNUSED, int type EINA_UNUSED, void *event EINA_UNUSED)
1692 {
1693    if (!comp_grabbed) return ECORE_CALLBACK_RENEW;
1694
1695    if (!action_client)
1696      ERR("no action_client!");
1697
1698    if (action_client) _e_client_resize_end(action_client);
1699    _e_client_action_finish();
1700    return ECORE_CALLBACK_DONE;
1701 }
1702
1703 ////////////////////////////////////////////////
1704
1705 static Eina_Bool
1706 _e_client_position_inside_input_rect(E_Client *ec, int tx, int ty)
1707 {
1708    int x, y, w, h;
1709    Eina_Bool res = EINA_FALSE;
1710    Eina_List *list = NULL, *l;
1711    Eina_Rectangle *data;
1712
1713    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
1714
1715    e_client_geometry_get(ec, &x, &y, &w, &h);
1716    e_comp_object_input_rect_get(ec->frame, &list);
1717    if (list)
1718      {
1719         EINA_LIST_FOREACH(list, l, data)
1720           {
1721              if ((tx >= x + data->x) && (tx <= x + data->x + data->w) &&
1722                  (ty >= y + data->y) && (ty <= y + data->y + data->h))
1723                {
1724                   res = EINA_TRUE;
1725                   break;
1726                }
1727           }
1728         list = eina_list_free(list);
1729      }
1730    else
1731      {
1732         if ((tx >= x) && (tx <= x + w) &&
1733             (ty >= y) && (ty <= y + h))
1734           {
1735              res = EINA_TRUE;
1736           }
1737      }
1738
1739    return res;
1740 }
1741
1742 static Eina_Bool
1743 _e_client_under_pointer_helper_ignore_client(E_Desk *desk, E_Client *client)
1744 {
1745    /* If a border was specified which should be excluded from the list
1746     * (because it will be closed shortly for example), skip */
1747    if (e_client_util_ignored_get(client) || (!e_desk_has_ec(desk, client))) return EINA_TRUE;
1748    if (!evas_object_visible_get(client->frame)) return EINA_TRUE;
1749    if (e_policy_client_is_cursor(client)) return EINA_TRUE;
1750    if (e_comp_wl->drag_client == client) return EINA_TRUE;
1751
1752    return EINA_FALSE;
1753 }
1754
1755 static E_Client *
1756 _e_client_under_pointer_helper(E_Desk *desk, E_Client *exclude, int x, int y)
1757 {
1758    E_Client *ec = NULL, *cec;
1759
1760    E_CLIENT_REVERSE_FOREACH(cec)
1761      {
1762         if (_e_client_under_pointer_helper_ignore_client(desk, cec)) continue;
1763         if ((exclude) && (cec == exclude)) continue;
1764         if (!E_INSIDE(x, y, cec->x, cec->y, cec->w, cec->h))
1765           continue;
1766         /* If the layer is higher, the position of the window is higher
1767          * (always on top vs always below) */
1768         if (!ec || (cec->layer > ec->layer))
1769           ec = cec;
1770      }
1771    return ec;
1772 }
1773
1774 static E_Client *
1775 _e_client_under_pointer_input_helper(E_Desk *desk, int x, int y)
1776 {
1777    E_Client *ec = NULL, *cec;
1778
1779    E_CLIENT_REVERSE_FOREACH(cec)
1780      {
1781         if (_e_client_under_pointer_helper_ignore_client(desk, cec)) continue;
1782
1783         Eina_List *list = NULL;
1784         Eina_Rectangle *rect;
1785         Eina_Bool inside = EINA_FALSE;
1786         e_comp_object_input_rect_get(cec->frame, &list);
1787         if (list)
1788           {
1789              EINA_LIST_FREE(list, rect)
1790                {
1791                   if (E_INSIDE(x, y, rect->x, rect->y, rect->w, rect->h))
1792                     inside = EINA_TRUE;
1793                }
1794           }
1795         else if (E_INSIDE(x, y, cec->x, cec->y, cec->w, cec->h))
1796           {
1797              inside = EINA_TRUE;
1798           }
1799
1800         if (!inside) continue;
1801         /* If the layer is higher, the position of the window is higher
1802          * (always on top vs always below) */
1803         if (!ec || (cec->layer > ec->layer))
1804           ec = cec;
1805      }
1806
1807    return ec;
1808 }
1809
1810 ////////////////////////////////////////////////
1811
1812 static void
1813 _e_client_zones_layout_calc(E_Client *ec, int *zx, int *zy, int *zw, int *zh)
1814 {
1815    int x, y, w, h;
1816    E_Zone *zone_above, *zone_below, *zone_left, *zone_right;
1817    E_Zone *zone;
1818
1819    zone = e_comp_zone_find_by_ec(ec);
1820    if (!zone) return;
1821    x = zone->x;
1822    y = zone->y;
1823    w = zone->w;
1824    h = zone->h;
1825
1826    if (eina_list_count(e_comp->zones) == 1)
1827      {
1828         if (zx) *zx = x;
1829         if (zy) *zy = y;
1830         if (zw) *zw = w;
1831         if (zh) *zh = h;
1832         return;
1833      }
1834
1835    zone_left = e_comp_zone_xy_get((x - w + 5), y);
1836    zone_right = e_comp_zone_xy_get((x + w + 5), y);
1837    zone_above = e_comp_zone_xy_get(x, (y - h + 5));
1838    zone_below = e_comp_zone_xy_get(x, (y + h + 5));
1839
1840    if (!(zone_above) && (y))
1841      zone_above = e_comp_zone_xy_get(x, (h - 5));
1842
1843    if (!(zone_left) && (x))
1844      zone_left = e_comp_zone_xy_get((x - 5), y);
1845
1846    if (zone_right)
1847      w = zone_right->x + zone_right->w;
1848
1849    if (zone_left)
1850      w = zone->x + zone->w;
1851
1852    if (zone_below)
1853      h = zone_below->y + zone_below->h;
1854
1855    if (zone_above)
1856      h = zone->y + zone->h;
1857
1858    if ((zone_left) && (zone_right))
1859      w = zone->w + zone_right->x;
1860
1861    if ((zone_above) && (zone_below))
1862      h = zone->h + zone_below->y;
1863
1864    if (x) x -= zone->w;
1865    if (y) y -= zone->h;
1866
1867    if (zx) *zx = x > 0 ? x : 0;
1868    if (zy) *zy = y > 0 ? y : 0;
1869    if (zw) *zw = w;
1870    if (zh) *zh = h;
1871 }
1872
1873 static void
1874 _e_client_stay_within_canvas(E_Client *ec, int x, int y, int *new_x, int *new_y)
1875 {
1876    int new_x_max, new_y_max;
1877    int zw, zh;
1878    Eina_Bool lw, lh;
1879    E_Zone *zone;
1880
1881    zone = e_comp_zone_find_by_ec(ec);
1882    if (!zone)
1883      {
1884         if (new_x) *new_x = x;
1885         if (new_y) *new_y = y;
1886         return;
1887      }
1888
1889    _e_client_zones_layout_calc(ec, NULL, NULL, &zw, &zh);
1890
1891    new_x_max = zw - ec->w;
1892    new_y_max = zh - ec->h;
1893    lw = ec->w > zw ? EINA_TRUE : EINA_FALSE;
1894    lh = ec->h > zh ? EINA_TRUE : EINA_FALSE;
1895
1896    if (lw)
1897      {
1898         if (x <= new_x_max)
1899           *new_x = new_x_max;
1900         else if (x >= 0)
1901           *new_x = 0;
1902      }
1903    else
1904      {
1905         if (x >= new_x_max)
1906           *new_x = new_x_max;
1907         else if (x <= 0)
1908           *new_x = 0;
1909      }
1910
1911    if (lh)
1912      {
1913         if (y <= new_y_max)
1914           *new_y = new_y_max;
1915         else if (y >= 0)
1916           *new_y = 0;
1917      }
1918    else
1919      {
1920         if (y >= new_y_max)
1921           *new_y = new_y_max;
1922         else if (y <= 0)
1923           *new_y = 0;
1924      }
1925 }
1926
1927 static void
1928 _e_client_stay_within_canvas_margin(E_Client *ec, int x, int y, int *new_x, int *new_y)
1929 {
1930    int new_x_max, new_y_max, new_x_min, new_y_min;
1931    int margin_w, margin_h;
1932    int zw, zh;
1933    int cw, ch;
1934    E_Zone *zone;
1935
1936    zone = e_comp_zone_find_by_ec(ec);
1937    if (!zone)
1938      {
1939         if (new_x) *new_x = x;
1940         if (new_y) *new_y = y;
1941         return;
1942      }
1943
1944    cw = ec->w;
1945    ch = ec->h;
1946
1947    _e_client_zones_layout_calc(ec, NULL, NULL, &zw, &zh);
1948
1949    margin_w = zw/3;
1950    margin_h = zh/10;
1951
1952    new_x_min = (margin_w > cw) ? 0 : -(cw - margin_w);
1953    new_x_max = (margin_w > cw) ? (zw - cw) : (zw - margin_w);
1954    new_y_min = (margin_h > ch) ? 0 : -(ch - margin_h);
1955    new_y_max = (margin_h > ch) ? (zh - ch) : (zh - margin_h);
1956
1957    if (x >= new_x_max)
1958      *new_x = new_x_max;
1959    else if (x <= new_x_min)
1960      *new_x = new_x_min;
1961
1962    if (y >= new_y_max)
1963      *new_y = new_y_max;
1964    else if (y <= new_y_min)
1965      *new_y = new_y_min;
1966
1967 }
1968
1969 ////////////////////////////////////////////////
1970
1971 static void
1972 _e_client_transform_core_activate_set(E_Client *ec, Eina_Bool set)
1973 {
1974    if (ec->transform_core.activate == set) return;
1975
1976    ec->transform_core.activate = set;
1977
1978    if (set)
1979      {
1980         if (ec->transform_core.result.enable)
1981           e_client_map_enable_set(ec, EINA_TRUE);
1982      }
1983    else
1984      {
1985         e_client_map_enable_set(ec, EINA_FALSE);
1986      }
1987 }
1988
1989 static void
1990 _e_client_cb_evas_hide(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
1991 {
1992    E_Client *ec = data;
1993
1994    if (stopping) return; //ignore all of this if we're shutting down!
1995    if (e_object_is_del(data)) return; //client is about to die
1996    if (ec->cur_mouse_action)
1997      {
1998         if (ec->cur_mouse_action->func.end_mouse)
1999           ec->cur_mouse_action->func.end_mouse(E_OBJECT(ec), "", NULL);
2000         else if (ec->cur_mouse_action->func.end)
2001           ec->cur_mouse_action->func.end(E_OBJECT(ec), "");
2002         E_FREE_FUNC(ec->cur_mouse_action, e_object_unref);
2003      }
2004    if (action_client == ec) _e_client_action_finish();
2005
2006    ec->want_focus = ec->take_focus = 0;
2007
2008    _e_client_transform_core_activate_set(ec, EINA_FALSE);
2009
2010    if (ec->new_client) return;
2011    _e_client_event_hide(ec);
2012
2013    EC_CHANGED(ec);
2014 }
2015
2016 static void
2017 _e_client_cb_evas_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
2018 {
2019    E_Client *ec = data;
2020    E_Map *map;
2021    Evas_Coord x, y;
2022
2023    if (e_object_is_del(data)) return;
2024
2025    ec->pre_res_change.valid = 0;
2026
2027    _e_client_event_simple(ec, E_EVENT_CLIENT_MOVE);
2028
2029    evas_object_geometry_get(ec->frame, &x, &y, NULL, NULL);
2030    if ((e_config->transient.move) && (ec->transients))
2031      {
2032         Eina_List *list = eina_list_clone(ec->transients);
2033         E_Client *child;
2034
2035         EINA_LIST_FREE(list, child)
2036           {
2037              if (child->vkbd.vkbd) continue;
2038
2039              evas_object_move(child->frame,
2040                               child->x + x - ec->pre_cb.x,
2041                               child->y + y - ec->pre_cb.y);
2042           }
2043      }
2044    if (ec->moving || (ecmove == ec))
2045      {
2046         wl_signal_emit_mutable(&PRI(ec)->events.move_resize_update, NULL);
2047         _e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec);
2048      }
2049
2050    if ((!ec->moving) && (ec->transformed))
2051      {
2052         map = e_client_map_get(ec);
2053         _e_client_transform_geometry_save(ec, map);
2054         e_map_free(map);
2055      }
2056
2057    ec->pre_cb.x = x; ec->pre_cb.y = y;
2058
2059    wl_signal_emit_mutable(&PRI(ec)->events.move, NULL);
2060
2061    e_comp_visibility_calculation_set(EINA_TRUE);
2062 }
2063
2064 static void
2065 _e_client_cb_evas_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
2066 {
2067    E_Client *ec = data;
2068    Evas_Coord x, y, w, h;
2069
2070    if (e_object_is_del(data)) return;
2071
2072    ec->pre_res_change.valid = 0;
2073
2074    _e_client_event_simple(ec, E_EVENT_CLIENT_RESIZE);
2075
2076    evas_object_geometry_get(ec->frame, &x, &y, &w, &h);
2077    if ((e_config->transient.resize) && (ec->transients))
2078      {
2079         Eina_List *list = eina_list_clone(ec->transients);
2080         E_Client *child;
2081
2082         EINA_LIST_FREE(list, child)
2083           {
2084              Evas_Coord nx, ny, nw, nh;
2085
2086              if ((ec->pre_cb.w > 0) && (ec->pre_cb.h > 0))
2087                {
2088                   nx = x + (((child->x - x) * w) / ec->pre_cb.w);
2089                   ny = y + (((child->y - y) * h) / ec->pre_cb.h);
2090                   nw = (child->w * w) / ec->pre_cb.w;
2091                   nh = (child->h * h) / ec->pre_cb.h;
2092                   nx += ((nw - child->w) / 2);
2093                   ny += ((nh - child->h) / 2);
2094                   evas_object_move(child->frame, nx, ny);
2095                }
2096           }
2097      }
2098
2099    if (e_client_util_resizing_get(ec) || (ecresize == ec))
2100      {
2101          wl_signal_emit_mutable(&PRI(ec)->events.move_resize_update, NULL);
2102         _e_client_hook_call(E_CLIENT_HOOK_RESIZE_UPDATE, ec);
2103      }
2104    ec->pre_cb.w = w; ec->pre_cb.h = h;
2105
2106    e_client_transform_core_update(ec);
2107    e_comp_visibility_calculation_set(EINA_TRUE);
2108 }
2109
2110 static void
2111 _e_client_cb_evas_show(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
2112 {
2113    E_Client *ec = data;
2114
2115    if (e_object_is_del(data)) return;
2116
2117    _e_client_transform_core_activate_set(ec, EINA_TRUE);
2118
2119    _e_client_event_show(ec);
2120    EC_CHANGED(ec);
2121 }
2122
2123 static void
2124 _e_client_cb_evas_restack(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
2125 {
2126    E_Client *ec = data;
2127    E_Comp_Wl_Client_Data *child_cdata = NULL;
2128
2129    if (e_object_is_del(data)) return;
2130    if (ec->layer_block) return;
2131    if (ec->layer_pending) return;
2132    if (e_config->transient.raise && ec->transients)
2133      {
2134         Eina_List *list = eina_list_clone(ec->transients);
2135         E_Client *child, *below = NULL, *above = NULL;
2136         E_Transient transient_policy;
2137
2138         E_LIST_REVERSE_FREE(list, child)
2139           {
2140              child_cdata = e_client_cdata_get(child);
2141              if (child_cdata && !child_cdata->mapped)
2142                {
2143                   ELOGF("COMP", "STACK CHANGE CHILD. BUT not mapped. skip. child(ec:%p, win:0x%08zx)", ec, child, e_client_util_win_get(child));
2144                   continue;
2145                }
2146
2147              /* Don't stack iconic transients. If the user wants these shown,
2148               * that's another option.
2149               */
2150              if (child->iconic && e_client_is_iconified_by_client(child)) continue;
2151
2152              transient_policy = e_client_transient_policy_get(child);
2153              if (transient_policy == E_TRANSIENT_ABOVE)
2154                {
2155                   if (below)
2156                     e_client_stack_below(child, below);
2157                   else
2158                     e_client_stack_above(child, ec);
2159                   below = child;
2160                }
2161              else if (transient_policy == E_TRANSIENT_BELOW)
2162                {
2163                   if (above)
2164                     e_client_stack_below(child, above);
2165                   else
2166                     e_client_stack_below(child, ec);
2167                   above = child;
2168                }
2169
2170           }
2171      }
2172    _e_client_event_simple(ec, E_EVENT_CLIENT_STACK);
2173
2174    e_comp_visibility_calculation_set(EINA_TRUE);
2175 }
2176
2177 ////////////////////////////////////////////////
2178 static void
2179 _e_client_aux_hint_eval(E_Client *ec)
2180 {
2181    if (!ec) return;
2182
2183    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
2184    Eina_List *l, *ll;
2185    E_Comp_Wl_Aux_Hint *hint;
2186
2187    if (cdata && cdata->aux_hint.changed)
2188      {
2189         wl_signal_emit_mutable(&PRI(ec)->events.aux_hint_change, NULL);
2190         _e_client_hook_call(E_CLIENT_HOOK_AUX_HINT_CHANGE, ec);
2191
2192         EINA_LIST_FOREACH_SAFE(cdata->aux_hint.hints, l, ll, hint)
2193           {
2194              hint->changed = EINA_FALSE;
2195              if (hint->deleted)
2196                {
2197                   ELOGF("COMP", "AUX_HINT |Del [%d:%s:%s]", ec, hint->id, hint->hint, hint->val);
2198                   if (hint->hint) eina_stringshare_del(hint->hint);
2199                   if (hint->val) eina_stringshare_del(hint->val);
2200                   cdata->aux_hint.hints = eina_list_remove_list(cdata->aux_hint.hints, l);
2201                   E_FREE(hint);
2202                }
2203           }
2204         cdata->aux_hint.changed = 0;
2205      }
2206 }
2207
2208 static void
2209 _e_client_eval(E_Client *ec)
2210 {
2211    int send_event = 1;
2212    unsigned int prop = 0;
2213    int tx, ty;
2214
2215    if (e_object_is_del(E_OBJECT(ec)))
2216      {
2217         CRI("_e_client_eval(%p) with deleted border! - %d\n", ec, ec->new_client);
2218         ec->changed = 0;
2219         return;
2220      }
2221
2222    TRACE_DS_BEGIN(CLIENT:EVAL);
2223
2224    wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_new_client, NULL);
2225    if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_NEW_CLIENT, ec))
2226      {
2227         TRACE_DS_END();
2228         return;
2229      }
2230
2231    if ((ec->new_client) && (!e_client_util_ignored_get(ec)))
2232      {
2233         wl_signal_emit_mutable(&PRI(ec)->events.eval_post_new_client, NULL);
2234         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_NEW_CLIENT, ec))
2235           {
2236              TRACE_DS_END();
2237              return;
2238           }
2239      }
2240
2241    if (ec->changes.size)
2242      {
2243         ec->changes.size = 0;
2244         evas_object_resize(ec->frame, ec->w, ec->h);
2245
2246         prop |= E_CLIENT_PROPERTY_SIZE;
2247      }
2248    if (ec->changes.pos)
2249      {
2250         ec->changes.tz_position = 0;
2251         ec->changes.pos = 0;
2252         evas_object_move(ec->frame, ec->x, ec->y);
2253         prop |= E_CLIENT_PROPERTY_POS;
2254      }
2255
2256    if (ec->changes.reset_gravity)
2257      {
2258         ec->changes.reset_gravity = 0;
2259         prop |= E_CLIENT_PROPERTY_GRAVITY;
2260      }
2261
2262    if (ec->changes.title)
2263      {
2264         ec->changes.title = 0;
2265         prop |= E_CLIENT_PROPERTY_TITLE;
2266      }
2267
2268    if ((ec->changes.visible) && (ec->visible) && (ec->new_client) && (!ec->iconic))
2269      {
2270         int x, y;
2271
2272         e_input_device_pointer_xy_get(NULL, &x, &y);
2273         if ((!ec->placed) && (!ec->re_manage) &&
2274             (e_config->window_placement_policy == E_WINDOW_PLACEMENT_MANUAL) &&
2275             (!((ec->icccm.transient_for != 0) ||
2276                (ec->dialog))) &&
2277             (!ecmove) && (!ecresize))
2278           {
2279              /* Set this window into moving state */
2280
2281              ec->cur_mouse_action = e_action_find("window_move");
2282              if (ec->cur_mouse_action)
2283                {
2284                   if ((!ec->cur_mouse_action->func.end_mouse) &&
2285                       (!ec->cur_mouse_action->func.end))
2286                     ec->cur_mouse_action = NULL;
2287                   if (ec->cur_mouse_action)
2288                     {
2289                        int t;
2290                        tx = x - (ec->w >> 1);
2291                        e_comp_object_frame_geometry_get(ec->frame, NULL, NULL, &t, NULL);
2292                        ty = y - (t >> 1);
2293                        e_client_pos_set(ec, tx, ty);
2294                        EC_CHANGED(ec);
2295                        ec->changes.pos = 1;
2296                     }
2297                }
2298           }
2299
2300         evas_object_show(ec->frame);
2301         if (evas_object_visible_get(ec->frame))
2302           {
2303              ec->changes.visible = 0;
2304              _e_client_event_show(ec);
2305           }
2306      }
2307    else if ((ec->changes.visible) && (ec->new_client))
2308      {
2309         ec->changes.visible = 0;
2310         if (!ec->iconic)
2311           _e_client_event_hide(ec);
2312      }
2313
2314    if (ec->changes.icon)
2315      {
2316         ec->changes.icon = 0;
2317      }
2318
2319    if (ec->new_client)
2320      e_comp->new_clients--;
2321    ec->new_client = 0;
2322    ec->changed = ec->changes.pos || ec->changes.size ||
2323                  ec->changes.stack || ec->changes.prop || ec->changes.border ||
2324                  ec->changes.reset_gravity ||
2325                  ec->changes.shape || ec->changes.shape_input || ec->changes.icon ||
2326                  ec->changes.internal_state ||
2327                  ec->changes.need_maximize || ec->changes.need_unmaximize;
2328    ec->changes.stack = 0;
2329
2330    if (ec->changes.need_maximize)
2331      {
2332         E_Maximize max = ec->maximized;
2333         ec->maximized = E_MAXIMIZE_NONE;
2334         e_client_maximize(ec, max);
2335         ec->changes.need_maximize = 0;
2336      }
2337    else if (ec->changes.need_unmaximize)
2338      {
2339         e_client_unmaximize(ec, ec->maximized);
2340         ec->changes.need_unmaximize = 0;
2341      }
2342
2343    if (ec->need_fullscreen)
2344      {
2345         e_client_fullscreen(ec, e_config->fullscreen_policy);
2346         ec->need_fullscreen = 0;
2347      }
2348
2349    if (ec->changes.accepts_focus)
2350      {
2351         if ((!ec->icccm.accepts_focus) && (!ec->icccm.take_focus))
2352           {
2353              if (!ec->focused)
2354                ec->changes.accepts_focus = 0;
2355           }
2356      }
2357
2358    if (send_event && prop)
2359      {
2360         _e_client_event_property(ec, prop);
2361      }
2362
2363    _e_client_aux_hint_eval(ec);
2364
2365    e_client_transform_core_update(ec);
2366
2367    wl_signal_emit_mutable(&PRI(ec)->events.eval_end, NULL);
2368    _e_client_hook_call(E_CLIENT_HOOK_EVAL_END, ec);
2369
2370    TRACE_DS_END();
2371 }
2372
2373 EINTERN void
2374 e_client_frame_update(E_Client *ec)
2375 {
2376    const char *bordername;
2377
2378    EINA_SAFETY_ON_NULL_RETURN(ec);
2379    if (e_object_is_del(E_OBJECT(ec))) return;
2380
2381    ec->border.changed = 0;
2382    if (!e_comp_object_frame_allowed(ec->frame)) return;
2383    if (ec->fullscreen || ec->borderless)
2384      bordername = "borderless";
2385    else if (ec->bordername)
2386      bordername = ec->bordername;
2387    else if (((ec->icccm.transient_for != 0) || (ec->dialog)) &&
2388             (ec->icccm.min_w == ec->icccm.max_w) &&
2389             (ec->icccm.min_h == ec->icccm.max_h))
2390      bordername = "noresize_dialog";
2391    else if ((ec->icccm.min_w == ec->icccm.max_w) &&
2392             (ec->icccm.min_h == ec->icccm.max_h))
2393      bordername = "noresize";
2394    else if (ec->shaped)
2395      bordername = "shaped";
2396    else if ((ec->netwm.state.skip_taskbar) ||
2397             (ec->netwm.state.skip_pager))
2398      bordername = "skipped";
2399   /*
2400    else if ((ec->internal) && (ec->icccm.class) &&
2401             (!strncmp(ec->icccm.class, "e_fwin", 6)))
2402      bordername = "internal_fileman";
2403   */
2404    else
2405      bordername = e_config->theme_default_border_style;
2406    if (!bordername) bordername = "default";
2407
2408    e_client_border_set(ec, bordername);
2409 }
2410
2411 static Eina_Bool
2412 _e_client_type_match(E_Client *ec, E_Config_Client_Type *m)
2413 {
2414    if (!ec || !m) return EINA_FALSE;
2415    if (e_object_is_del(E_OBJECT(ec))) return EINA_FALSE;
2416
2417    if ((int)ec->netwm.type != m->window_type)
2418      return EINA_FALSE;
2419
2420 #if defined(__cplusplus) || defined(c_plusplus)
2421    if (m->clas)
2422      {
2423         if (!ec->icccm.cpp_class)
2424           return EINA_FALSE;
2425
2426         if (!e_util_glob_match(ec->icccm.cpp_class, m->clas))
2427           return EINA_FALSE;
2428      }
2429 #else
2430    if (m->clas)
2431      {
2432         if (!ec->icccm.class)
2433           return EINA_FALSE;
2434
2435         if (!e_util_glob_match(ec->icccm.class, m->clas))
2436           return EINA_FALSE;
2437      }
2438 #endif
2439
2440    if (m->name)
2441      {
2442         if (ec->icccm.name && e_util_glob_match(ec->icccm.name, m->name))
2443           return EINA_TRUE;
2444
2445         if (ec->icccm.title && e_util_glob_match(ec->icccm.title, m->name))
2446           return EINA_TRUE;
2447
2448         if (ec->netwm.name && e_util_glob_match(ec->netwm.name, m->name))
2449           return EINA_TRUE;
2450      }
2451
2452    return EINA_FALSE;
2453 }
2454
2455 EINTERN int
2456 e_client_type_update(E_Client *ec)
2457 {
2458    E_Config_Client_Type *m;
2459    Eina_List *l;
2460    int type = 0;
2461
2462    if (!e_config->client_types) return 0;
2463
2464    EINA_LIST_FOREACH(e_config->client_types, l, m)
2465      {
2466         if (!_e_client_type_match(ec, m)) continue;
2467         else
2468           {
2469              type = m->client_type;
2470              break;
2471           }
2472      }
2473
2474    if (ec->client_type != type)
2475      {
2476         ec->client_type = type;
2477         _e_client_event_property(ec, E_CLIENT_PROPERTY_CLIENT_TYPE);
2478      }
2479
2480    return ec->client_type;
2481 }
2482
2483 static void
2484 _e_client_transform_sub_apply(E_Client *ec, E_Client *epc, double zoom)
2485 {
2486    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
2487    E_Client *subc;
2488    Eina_List *l;
2489    int px = 0, py = 0;
2490    int ox = 0, oy = 0, ow, oh;
2491    int mx, my, mw, mh;
2492    E_Map *map;
2493
2494    EINA_SAFETY_ON_FALSE_RETURN(e_comp_wl_subsurface_check(ec));
2495
2496    e_comp_wl_subsurface_position_get(ec, &ox, &oy);
2497    ow = cdata->width_from_viewport;
2498    oh = cdata->height_from_viewport;
2499
2500    map = e_client_map_get(epc);
2501    e_map_point_coord_get(map, 0, &px, &py, 0);
2502    e_map_free(map);
2503
2504    mx = ox * zoom + px;
2505    my = oy * zoom + py;
2506    mw = ow * zoom;
2507    mh = oh * zoom;
2508
2509    map = e_map_new_with_direct_render(ec->transform_core.direct_render);
2510    e_map_util_points_populate_from_geometry(map, mx, my, mw, mh, 0);
2511    e_map_util_object_move_sync_set(map, EINA_TRUE);
2512    e_client_map_set(ec, map);
2513    e_client_map_enable_set(ec, EINA_TRUE);
2514
2515    EINA_LIST_FOREACH(cdata->sub.list, l, subc)
2516      _e_client_transform_sub_apply(subc, ec, zoom);
2517    EINA_LIST_REVERSE_FOREACH(cdata->sub.below_list, l, subc)
2518      _e_client_transform_sub_apply(subc, ec, zoom);
2519
2520    e_map_free(map);
2521 }
2522
2523 static void
2524 _e_client_transient_for_group_make(E_Client *ec, Eina_List **list)
2525 {
2526    E_Client *child;
2527    Eina_List *l;
2528
2529    if (!ec) return;
2530    if (!e_config->transient.raise) return;
2531
2532    EINA_LIST_FOREACH(ec->transients, l, child)
2533      {
2534         if (!child) continue;
2535         if (child->iconic) continue;
2536         if (e_client_transient_policy_get(child) == E_TRANSIENT_ABOVE)
2537           {
2538              *list = eina_list_prepend(*list, child);
2539              _e_client_transient_for_group_make(child, list);
2540           }
2541      }
2542 }
2543
2544 EINTERN E_Client *
2545 e_client_transient_child_top_get(E_Client *ec, Eina_Bool consider_focus)
2546 {
2547    E_Client *top_ec = NULL;
2548    Eina_List *transient_list = NULL;
2549
2550    _e_client_transient_for_group_make(ec, &transient_list);
2551
2552    if (transient_list)
2553      {
2554         Eina_List *l = NULL;
2555         E_Client *temp_ec = NULL;
2556         E_Client *temp_ec2 = NULL;
2557
2558         E_CLIENT_REVERSE_FOREACH(temp_ec)
2559           {
2560              if (top_ec) break;
2561              if (temp_ec == ec)
2562                {
2563                   top_ec = ec;
2564                   break;
2565                }
2566
2567              EINA_LIST_FOREACH(transient_list, l, temp_ec2)
2568                {
2569                   if (temp_ec == temp_ec2)
2570                     {
2571                        if (consider_focus)
2572                          {
2573                             if ((temp_ec2->icccm.accepts_focus) ||
2574                                 (temp_ec2->icccm.take_focus))
2575                               {
2576                                  top_ec = temp_ec2;
2577                               }
2578                          }
2579                        else
2580                          {
2581                             top_ec = temp_ec2;
2582                          }
2583                        break;
2584                     }
2585                }
2586           }
2587         eina_list_free(transient_list);
2588      }
2589    return top_ec;
2590 }
2591
2592 #ifdef EC_IS_NOT_VISIBLE
2593 # undef EC_IS_NOT_VISIBLE
2594 #endif
2595 #define EC_IS_NOT_VISIBLE if (ec->visibility.obscured != E_VISIBILITY_UNOBSCURED)
2596
2597 EINTERN Eina_Bool
2598 e_client_visibility_touched_check(E_Client *ec)
2599 {
2600    int tx, ty;
2601
2602    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
2603
2604    tx = wl_fixed_to_int(e_comp->wl_comp_data->ptr.x);
2605    ty = wl_fixed_to_int(e_comp->wl_comp_data->ptr.y);
2606
2607    return _e_client_position_inside_input_rect(ec, tx, ty);
2608 }
2609
2610 EINTERN void
2611 e_client_visibility_change_notify(E_Client *ec)
2612 {
2613    EINA_SAFETY_ON_NULL_RETURN(ec);
2614
2615    if (ec->visibility.changed)
2616      _e_client_event_simple(ec, E_EVENT_CLIENT_VISIBILITY_CHANGE);
2617
2618    wl_signal_emit_mutable(&PRI(ec)->events.eval_visibility, NULL);
2619    _e_client_hook_call(E_CLIENT_HOOK_EVAL_VISIBILITY, ec);
2620 }
2621
2622 EINTERN void
2623 e_client_visibility_end_notify(void)
2624 {
2625    // FIXME: This hook means that the visiblitiy calculation of a zone is done
2626    //        at this idle handler.This is a hook for a zone, not for a client.
2627    //        Therefore, this hook may be defined as a zone hook,
2628    //        ex) E_ZONE_HOOK_EVAL_VISIBILITY_END or E_ZONE_HOOK_EVAL_VISIBILITY_DONE.
2629    _e_client_hook_call(E_CLIENT_HOOK_EVAL_VISIBILITY_END, NULL);
2630 }
2631
2632 static Eina_Bool
2633 _e_client_transform_core_check_change(E_Client *ec)
2634 {
2635    int w = 0;
2636    int h = 0;
2637    Eina_Bool check = EINA_FALSE;
2638    if (!ec) return EINA_FALSE;
2639
2640    if (ec->frame)
2641      evas_object_geometry_get(ec->frame, 0, 0, &w, &h);
2642
2643    // check client position or size change
2644    if (ec->x != ec->transform_core.backup.client_x ||
2645        ec->y != ec->transform_core.backup.client_y ||
2646        ec->w != ec->transform_core.backup.client_w ||
2647        ec->h != ec->transform_core.backup.client_h ||
2648        w     != ec->transform_core.backup.frame_w ||
2649        h     != ec->transform_core.backup.frame_h ||
2650        ec->argb != ec->transform_core.backup.argb)
2651      {
2652         check = EINA_TRUE;
2653         ec->transform_core.backup.client_x = ec->x;
2654         ec->transform_core.backup.client_y = ec->y;
2655         ec->transform_core.backup.client_w = ec->w;
2656         ec->transform_core.backup.client_h = ec->h;
2657         ec->transform_core.backup.frame_w = w;
2658         ec->transform_core.backup.frame_h = h;
2659         ec->transform_core.backup.argb = ec->argb;
2660      }
2661
2662    // check new transform or del transform
2663    if (ec->transform_core.changed)
2664      {
2665         check = EINA_TRUE;
2666         ec->transform_core.changed = EINA_FALSE;
2667      }
2668
2669    // check each transform change
2670    if (ec->transform_core.transform_list)
2671      {
2672         Eina_List *l;
2673         Eina_List *l_next;
2674         E_Util_Transform *transform;
2675
2676         EINA_LIST_FOREACH_SAFE(ec->transform_core.transform_list, l, l_next, transform)
2677           {
2678              // del transform check
2679              if (e_util_transform_ref_count_get(transform) <= 1)
2680                {
2681                   ec->transform_core.transform_list = eina_list_remove(ec->transform_core.transform_list, transform);
2682                   e_util_transform_unref(transform);
2683                   check = EINA_TRUE;
2684                   continue;
2685                }
2686
2687              // transform change test
2688              if (e_util_transform_change_get(transform))
2689                {
2690                   check = EINA_TRUE;
2691                   e_util_transform_change_unset(transform);
2692                }
2693           }
2694      }
2695
2696    if (e_comp_wl_subsurface_check(ec))
2697      {
2698         // check parent matrix change
2699         E_Client *parent = e_comp_wl_subsurface_parent_get(ec);
2700         if (parent && parent->transform_core.result.enable)
2701           {
2702              ec->transform_core.parent.enable = EINA_TRUE;
2703
2704              if (!e_util_transform_matrix_equal_check(&ec->transform_core.parent.matrix,
2705                                                       &parent->transform_core.result.matrix))
2706                {
2707                   check = EINA_TRUE;
2708                   ec->transform_core.parent.matrix = parent->transform_core.result.matrix;
2709                }
2710              if (memcmp(&ec->transform_core.parent.zoom, &parent->transform_core.result.transform.zoom, sizeof(E_Util_Transform_Zoom)) != 0)
2711                {
2712                   check = EINA_TRUE;
2713                   ec->transform_core.parent.zoom = parent->transform_core.result.transform.zoom;
2714                }
2715           }
2716         else if (ec->transform_core.parent.enable)
2717           {
2718              ec->transform_core.parent.enable = EINA_FALSE;
2719              e_util_transform_matrix_load_identity(&ec->transform_core.parent.matrix);
2720              ec->transform_core.parent.zoom.zoom_x = 1.0;
2721              ec->transform_core.parent.zoom.zoom_y = 1.0;
2722              ec->transform_core.parent.zoom.cx = 0;
2723              ec->transform_core.parent.zoom.cy = 0;
2724              check = EINA_TRUE;
2725           }
2726      }
2727
2728    return check;
2729 }
2730
2731 static void
2732 _e_client_transform_core_boundary_update(E_Client *ec, E_Util_Transform_Rect_Vertex *vertices)
2733 {
2734    int minx = 99999, miny = 99999;
2735    int maxx = -99999, maxy = -99999;
2736    int x, y;
2737    int i;
2738
2739    if (!ec) return;
2740    if (!ec->frame) return;
2741    if (!ec->transform_core.result.enable) return;
2742    if (!vertices) return;
2743
2744    for (i = 0; i < 4; ++i)
2745      {
2746         x = 0;
2747         y = 0;
2748
2749         e_util_transform_vertices_pos_round_get(vertices, i, &x, &y, 0, 0);
2750
2751         if (x < minx) minx = x;
2752         if (y < miny) miny = y;
2753         if (x > maxx) maxx = x;
2754         if (y > maxy) maxy = y;
2755      }
2756
2757    ec->transform_core.result.boundary.x = minx;
2758    ec->transform_core.result.boundary.y = miny;
2759    ec->transform_core.result.boundary.w = maxx - minx;
2760    ec->transform_core.result.boundary.h = maxy - miny;
2761
2762    ELOGF("COMP", "[Transform][boundary][%d %d %d %d]",
2763          ec,
2764          ec->transform_core.result.boundary.x,
2765          ec->transform_core.result.boundary.y,
2766          ec->transform_core.result.boundary.w,
2767          ec->transform_core.result.boundary.h);
2768 }
2769
2770 static E_Map *
2771 _e_client_transform_core_map_new(Evas_Object *obj,
2772                                  E_Util_Transform_Rect_Vertex *vertices,
2773                                  E_Util_Transform *transform,
2774                                  Eina_Bool direct_render)
2775 {
2776    E_Map *map;
2777    int i;
2778    int x, y;
2779    double u, v;
2780
2781    map = e_map_new_with_direct_render(direct_render);
2782    EINA_SAFETY_ON_NULL_RETURN_VAL(map, NULL);
2783
2784    e_map_util_points_populate_from_object_full(map, obj, 0);
2785    e_map_util_points_color_set(map, 255, 255, 255, 255);
2786
2787    for (i = 0 ; i < 4 ; ++i)
2788      {
2789         x = 0;
2790         y = 0;
2791
2792         e_util_transform_vertices_pos_round_get(vertices, i, &x, &y, 0, 0);
2793         e_map_point_coord_set(map, i, x, y, 1.0);
2794
2795         if (transform && e_util_transform_texcoord_flag_get(transform))
2796           {
2797              u = 0.0;
2798              v = 0.0;
2799
2800              e_util_transform_texcoord_get(transform, i, &u, &v);
2801              e_map_point_image_uv_set(map, i, u, v);
2802           }
2803      }
2804
2805    return map;
2806 }
2807
2808 static void
2809 _e_client_transform_core_vertices_apply_with_zoom(E_Client *ec,
2810                                         Evas_Object *obj,
2811                                         E_Util_Transform_Rect_Vertex *vertices,
2812                                         E_Util_Transform *transform,
2813                                         E_Util_Transform_Zoom zoom)
2814 {
2815    E_Map *map = NULL;
2816
2817    if (!obj) return;
2818
2819    if (vertices)
2820      {
2821         map = _e_client_transform_core_map_new(obj, vertices, transform,
2822                                                ec->transform_core.direct_render);
2823         EINA_SAFETY_ON_NULL_RETURN(map);
2824
2825         e_map_util_zoom(map, zoom.zoom_x, zoom.zoom_y, zoom.cx, zoom.cy);
2826
2827         e_comp_object_map_set(obj, map);
2828
2829         if (ec->transform_core.activate)
2830           e_comp_object_map_enable_set(obj, EINA_TRUE);
2831         else
2832           e_comp_object_map_enable_set(obj, EINA_FALSE);
2833
2834         e_map_free(map);
2835      }
2836    else
2837      evas_object_map_enable_set(obj, EINA_FALSE);
2838 }
2839
2840 static void
2841 _e_client_transform_core_vertices_apply(E_Client *ec,
2842                                         Evas_Object *obj,
2843                                         E_Util_Transform_Rect_Vertex *vertices,
2844                                         E_Util_Transform *transform)
2845 {
2846    E_Map *map = NULL;
2847
2848    if (!obj) return;
2849
2850    if (vertices)
2851      {
2852         map = _e_client_transform_core_map_new(obj, vertices, transform,
2853                                                ec->transform_core.direct_render);
2854         EINA_SAFETY_ON_NULL_RETURN(map);
2855
2856         e_comp_object_map_set(obj, map);
2857
2858         if (ec->transform_core.activate)
2859           e_comp_object_map_enable_set(obj, EINA_TRUE);
2860         else
2861           e_comp_object_map_enable_set(obj, EINA_FALSE);
2862
2863         e_map_free(map);
2864      }
2865    else
2866      evas_object_map_enable_set(obj, EINA_FALSE);
2867 }
2868
2869 static void
2870 _e_client_transform_core_sub_update(E_Client *ec, E_Util_Transform_Rect_Vertex *vertices)
2871 {
2872    Eina_List *l;
2873    E_Client *subc;
2874    E_Comp_Wl_Client_Data *cdata;
2875
2876    if (!ec) return;
2877
2878    cdata = e_client_cdata_get(ec);
2879    if (!cdata) return;
2880
2881    EINA_LIST_FOREACH(cdata->sub.list, l, subc)
2882       e_client_transform_core_update(subc);
2883
2884    EINA_LIST_FOREACH(cdata->sub.below_list, l, subc)
2885       e_client_transform_core_update(subc);
2886 }
2887
2888 static void
2889 _e_client_cb_hook_shell_surface_ready(void *data EINA_UNUSED, E_Client *ec)
2890 {
2891    if (EINA_UNLIKELY(!ec))
2892      return;
2893
2894    _e_client_aux_hint_eval(ec);
2895 }
2896
2897 // FIXME: This function has to be deleted and it remains for the backward compatibility.
2898 //        Please find and fix to use e_comp_visibility_calculation_set(EINA_TRUE)
2899 //        instead of e_client_visibility_calculate() call at e20 modules.
2900 E_API void
2901 e_client_visibility_calculate(void)
2902 {
2903    e_comp_visibility_calculation_set(EINA_TRUE);
2904 }
2905
2906 E_API void
2907 e_client_visibility_skip_set(E_Client *ec, Eina_Bool skip)
2908 {
2909    if (!ec) return;
2910
2911    ELOGF("POL_VIS", "visibility skip set to %d", ec, skip);
2912    ec->visibility.skip = skip;
2913 }
2914
2915 E_API void
2916 e_client_post_raise_lower_set(E_Client *ec, Eina_Bool raise_set, Eina_Bool lower_set)
2917 {
2918    if (!ec) return;
2919
2920    ec->post_raise = raise_set;
2921    ec->post_lower = lower_set;
2922 }
2923
2924 E_API Eina_Bool
2925 e_client_first_mapped_get(E_Client *ec)
2926 {
2927    if (!ec) return EINA_FALSE;
2928
2929    return ec->first_mapped;
2930 }
2931
2932 EINTERN Eina_Bool e_client_mapped_get(E_Client *ec)
2933 {
2934    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
2935    EINA_SAFETY_ON_NULL_RETURN_VAL(cdata, EINA_FALSE);
2936
2937   return cdata->mapped;
2938 }
2939
2940 EINTERN void
2941 e_client_mapped_set(E_Client *ec, Eina_Bool set)
2942 {
2943    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
2944    EINA_SAFETY_ON_NULL_RETURN(cdata);
2945
2946    cdata->mapped = set;
2947 }
2948
2949
2950 ////////////////////////////////////////////////
2951 EINTERN Eina_Bool
2952 e_client_clients_hash_exist()
2953 {
2954   int pix_id;
2955
2956   for (pix_id = 0; pix_id < E_PIXMAP_TYPE_MAX; pix_id++)
2957     {
2958       if (eina_hash_population(clients_hash[pix_id]))
2959         return EINA_TRUE;
2960     }
2961
2962   return EINA_FALSE;
2963 }
2964
2965 EINTERN void
2966 e_client_idler_before(Eina_Bool *check_focus)
2967 {
2968    const Eina_List *l;
2969    E_Client *ec;
2970
2971    *check_focus = EINA_FALSE;
2972
2973    if (!e_client_clients_hash_exist()) return;
2974
2975    TRACE_DS_BEGIN(CLIENT:IDLE BEFORE);
2976
2977    EINA_LIST_FOREACH(e_comp->clients, l, ec)
2978      {
2979         // pass 1 - eval0. fetch properties on new or on change and
2980         // call hooks to decide what to do - maybe move/resize
2981         if (ec->ignored || (!ec->changed)) continue;
2982
2983         wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_fetch, NULL);
2984         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_FETCH, ec)) continue;
2985
2986
2987         /* FETCH is hooked by the compositor to get client hints */
2988         wl_signal_emit_mutable(&PRI(ec)->events.eval_fetch, NULL);
2989         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_FETCH, ec)) continue;
2990
2991         if (ec->new_client)
2992           {
2993              e_client_type_update(ec);
2994           }
2995
2996         /* PRE_POST_FETCH calls e_remember apply for new client */
2997         wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_post_fetch, NULL);
2998         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_POST_FETCH, ec)) continue;
2999         wl_signal_emit_mutable(&PRI(ec)->events.eval_post_fetch, NULL);
3000         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_FETCH, ec)) continue;
3001         wl_signal_emit_mutable(&PRI(ec)->events.eval_pre_frame_assign, NULL);
3002         if (!_e_client_hook_call(E_CLIENT_HOOK_EVAL_PRE_FRAME_ASSIGN, ec)) continue;
3003
3004         wl_signal_emit_mutable(&PRI(ec)->events.eval_post_frame_assign, NULL);
3005         _e_client_hook_call(E_CLIENT_HOOK_EVAL_POST_FRAME_ASSIGN, ec);
3006      }
3007    // pass 2 - show and hide windows needing hide and eval (main eval)
3008    E_CLIENT_FOREACH(ec)
3009      {
3010         if (e_object_is_del(E_OBJECT(ec))) continue;
3011         if (ec->ignored)
3012           {
3013              // ignored client but needing eval (aux hint) such as remote surfaces
3014              if (ec->changed)
3015                {
3016                   E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
3017                   if (cdata && cdata->first_commit)
3018                     _e_client_aux_hint_eval(ec);
3019                }
3020              continue;
3021           }
3022
3023         if (ec->changes.visible)
3024           {
3025              if (ec->visible)
3026                {
3027                   if ((!ec->new_client) &&
3028                       (!ec->changes.pos) &&
3029                       (!ec->changes.size))
3030                     {
3031                        evas_object_show(ec->frame);
3032                        ec->changes.visible = !evas_object_visible_get(ec->frame);
3033                     }
3034                }
3035              else
3036                {
3037                   evas_object_hide(ec->frame);
3038                   ec->changes.visible = 0;
3039                }
3040           }
3041
3042         if (ec->changed)
3043           {
3044              _e_client_eval(ec);
3045              e_comp_visibility_calculation_set(EINA_TRUE);
3046              if (ec->changes.accepts_focus)
3047                *check_focus = EINA_TRUE;
3048              ec->changes.accepts_focus = 0;
3049           }
3050
3051         if ((ec->changes.visible) && (ec->visible) && (!ec->changed))
3052           {
3053              evas_object_show(ec->frame);
3054              ec->changes.visible = !evas_object_visible_get(ec->frame);
3055              ec->changed = ec->changes.visible;
3056              e_comp_visibility_calculation_set(EINA_TRUE);
3057           }
3058      }
3059
3060    TRACE_DS_END();
3061 }
3062
3063
3064 EINTERN Eina_Bool
3065 e_client_init(void)
3066 {
3067    int pix_id;
3068    for (pix_id = 0; pix_id < E_PIXMAP_TYPE_MAX; pix_id++)
3069      clients_hash[pix_id] = eina_hash_pointer_new(NULL);
3070
3071    E_COMP_WL_HOOK_APPEND(hooks, E_COMP_WL_HOOK_SHELL_SURFACE_READY, _e_client_cb_hook_shell_surface_ready, NULL);
3072
3073    E_EVENT_CLIENT_ADD = ecore_event_type_new();
3074    E_EVENT_CLIENT_REMOVE = ecore_event_type_new();
3075    E_EVENT_CLIENT_DESK_SET = ecore_event_type_new();
3076    E_EVENT_CLIENT_ZONE_SET = ecore_event_type_new();
3077    E_EVENT_CLIENT_RESIZE = ecore_event_type_new();
3078    E_EVENT_CLIENT_MOVE = ecore_event_type_new();
3079    E_EVENT_CLIENT_SHOW = ecore_event_type_new();
3080    E_EVENT_CLIENT_HIDE = ecore_event_type_new();
3081    E_EVENT_CLIENT_ICONIFY = ecore_event_type_new();
3082    E_EVENT_CLIENT_UNICONIFY = ecore_event_type_new();
3083    E_EVENT_CLIENT_STACK = ecore_event_type_new();
3084    E_EVENT_CLIENT_FOCUS_IN = ecore_event_type_new();
3085    E_EVENT_CLIENT_FOCUS_OUT = ecore_event_type_new();
3086    E_EVENT_CLIENT_PROPERTY = ecore_event_type_new();
3087    E_EVENT_CLIENT_FULLSCREEN = ecore_event_type_new();
3088    E_EVENT_CLIENT_UNFULLSCREEN = ecore_event_type_new();
3089 #ifdef _F_ZONE_WINDOW_ROTATION_
3090    E_EVENT_CLIENT_ROTATION_CHANGE_BEGIN = ecore_event_type_new();
3091    E_EVENT_CLIENT_ROTATION_CHANGE_CANCEL = ecore_event_type_new();
3092    E_EVENT_CLIENT_ROTATION_CHANGE_END = ecore_event_type_new();
3093    E_EVENT_CLIENT_ROTATION_GEOMETRY_SET = ecore_event_type_new();
3094 #endif
3095    E_EVENT_CLIENT_VISIBILITY_CHANGE = ecore_event_type_new();
3096    E_EVENT_CLIENT_BUFFER_CHANGE = ecore_event_type_new();
3097    E_EVENT_CLIENT_FOCUS_SKIP_SET = ecore_event_type_new();;
3098    E_EVENT_CLIENT_FOCUS_SKIP_UNSET = ecore_event_type_new();;
3099
3100    return (!!clients_hash[1]);
3101 }
3102
3103 EINTERN void
3104 e_client_shutdown(void)
3105 {
3106    int pix_id;
3107    for (pix_id = 0; pix_id < E_PIXMAP_TYPE_MAX; pix_id++)
3108      E_FREE_FUNC(clients_hash[pix_id], eina_hash_free);
3109
3110    E_FREE_LIST(hooks, e_comp_wl_hook_del);
3111    E_FREE_LIST(handlers, ecore_event_handler_del);
3112
3113 }
3114
3115 E_API void
3116 e_client_unignore(E_Client *ec)
3117 {
3118    E_OBJECT_CHECK(ec);
3119    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
3120    if (!ec->ignored) return;
3121
3122    ec->ignored = 0;
3123    _e_client_event_add(ec);
3124 }
3125
3126 static E_Layer
3127 _e_client_convert_fullscreen_layer(int layer)
3128 {
3129    if (layer <= E_LAYER_CLIENT_NORMAL)
3130      return E_LAYER_CLIENT_NORMAL;
3131    else if (layer <= E_LAYER_CLIENT_ABOVE)
3132      return E_LAYER_CLIENT_ABOVE;
3133    else if (layer <= E_LAYER_CLIENT_EDGE)
3134      return E_LAYER_CLIENT_EDGE;
3135    else
3136      return E_LAYER_CLIENT_FULLSCREEN;
3137 }
3138
3139 E_API E_Client *
3140 e_client_new(E_Pixmap *cp, int first_map, int internal)
3141 {
3142    E_Client *ec;
3143    E_Pixmap_Type type;
3144
3145    type = e_pixmap_type_get(cp);
3146    if (type >= E_PIXMAP_TYPE_MAX) return NULL;
3147    if (eina_hash_find(clients_hash[type], &cp)) return NULL;
3148
3149    ec = E_OBJECT_ALLOC(E_Client, E_CLIENT_TYPE, _e_client_free);
3150    if (!ec) return NULL;
3151    e_object_del_func_set(E_OBJECT(ec), E_OBJECT_CLEANUP_FUNC(_e_client_del));
3152
3153    if (!_e_client_private_init(ec))
3154      {
3155         e_object_del(E_OBJECT(ec));
3156         return NULL;
3157      }
3158
3159    uuid_generate(ec->uuid);
3160
3161    ec->focus_policy_override = E_FOCUS_LAST;
3162    e_client_size_set(ec, 1, 1);
3163    ec->internal = internal;
3164
3165    ec->pixmap = cp;
3166    e_pixmap_client_set(cp, ec);
3167    ec->resize_mode = E_POINTER_RESIZE_NONE;
3168    ec->layer = E_LAYER_CLIENT_NORMAL;
3169    ec->first_mapped = EINA_FALSE;
3170    ec->post_raise = EINA_TRUE;
3171    ec->post_lower = EINA_FALSE;
3172    ec->animatable = EINA_TRUE;
3173    ec->maximize_type = e_config->maximize_policy & E_MAXIMIZE_TYPE;
3174    ec->fullscreen_layer = _e_client_convert_fullscreen_layer(e_config->fullscreen_layer);
3175
3176    /* FIXME: if first_map is 1 then we should ignore the first hide event
3177     * or ensure the window is already hidden and events flushed before we
3178     * create a border for it */
3179    if (first_map)
3180      {
3181         ec->changes.pos = 1;
3182         ec->re_manage = 1;
3183      }
3184    ec->new_client = 1;
3185    e_comp->new_clients++;
3186
3187    ec->exp_iconify.by_client = 0;
3188    ec->exp_iconify.not_raise = 0;
3189    ec->exp_iconify.skip_iconify = 0;
3190    ec->exp_iconify.skip_by_remote = 0;
3191    if (e_config->deiconify_approve)
3192      ec->exp_iconify.deiconify_update= 1;
3193    else
3194      ec->exp_iconify.deiconify_update= 0;
3195    if (e_config->use_buffer_flush)
3196      ec->exp_iconify.buffer_flush = 1;
3197    else
3198      ec->exp_iconify.buffer_flush = 0;
3199
3200    e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
3201
3202    wl_signal_emit_mutable(&PRI(ec)->events.new_client, NULL);
3203    if (!_e_client_hook_call(E_CLIENT_HOOK_NEW_CLIENT, ec))
3204      {
3205         /* delete the above allocated object */
3206         //e_object_del(E_OBJECT(ec));
3207         return NULL;
3208      }
3209
3210    _e_client_aux_hint_eval(ec);
3211
3212    ec->icccm.title = NULL;
3213    ec->icccm.name = NULL;
3214 #if defined(__cplusplus) || defined(c_plusplus)
3215    ec->icccm.cpp_class = NULL;
3216 #else
3217    ec->icccm.class = NULL;
3218 #endif
3219    ec->icccm.min_w = 1;
3220    ec->icccm.min_h = 1;
3221    ec->icccm.max_w = 32767;
3222    ec->icccm.max_h = 32767;
3223
3224    ec->netwm.pid = 0;
3225    ec->netwm.name = NULL;
3226    ec->netwm.state.skip_taskbar = 0;
3227    ec->netwm.state.skip_pager = 0;
3228    ec->netwm.opacity = 255;
3229
3230    ec->visibility.obscured = E_VISIBILITY_UNKNOWN;
3231    ec->visibility.opaque = -1;
3232    ec->visibility.changed = 0;
3233    ec->visibility.skip = 0;
3234    ec->visibility.last_sent_type = E_VISIBILITY_UNKNOWN;
3235
3236    ec->transform.zoom = 1.0;
3237    ec->transform.angle = 0.0;
3238    ec->transform_core.direct_render = EINA_TRUE;
3239    ec->transform_core.activate = EINA_TRUE;
3240
3241    ec->pointer_enter_sent = EINA_FALSE;
3242
3243    ec->acquire_fence_fd = -1;
3244
3245    EC_CHANGED(ec);
3246
3247    e_comp->clients = eina_list_append(e_comp->clients, ec);
3248    eina_hash_add(clients_hash[type], &ec->pixmap, ec);
3249
3250    ELOGF("COMP", "CLIENT ADD. cp:%p, argb:%d, internal:%d, ignored:%d", ec, cp, ec->argb, internal, ec->ignored);
3251    if (!ec->ignored)
3252      _e_client_event_add(ec);
3253    e_comp_object_client_add(ec);
3254    if (ec->frame)
3255      {
3256         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_SHOW, _e_client_cb_evas_show, ec);
3257         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_HIDE, _e_client_cb_evas_hide, ec);
3258         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_MOVE, _e_client_cb_evas_move, ec);
3259         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESIZE, _e_client_cb_evas_resize, ec);
3260         evas_object_event_callback_add(ec->frame, EVAS_CALLBACK_RESTACK, _e_client_cb_evas_restack, ec);
3261      }
3262
3263    wl_signal_emit_mutable(&PRI(ec)->events.new_client_post, NULL);
3264
3265 #ifdef _F_E_CLIENT_NEW_CLIENT_POST_HOOK_
3266    _e_client_hook_call(E_CLIENT_HOOK_NEW_CLIENT_POST, ec);
3267 #endif
3268
3269    ec->manage_resize.resize_obj = NULL;
3270    ec->manage_resize.x = ec->manage_resize.y = ec->manage_resize.w = ec->manage_resize.h = 0;
3271    ec->manage_resize.enable_aspect_ratio = EINA_FALSE;
3272    ec->manage_resize.aw = ec->manage_resize.ah = 0;
3273    ec->manage_resize.header_h = 0;
3274    ec->manage_resize.footer_h = 0;
3275
3276    ec->visibility.ignore_geometry = e_config->calc_vis_ignore_geometry;
3277
3278    return ec;
3279 }
3280
3281 E_API Eina_Bool e_client_is_internal(E_Client *ec)
3282 {
3283    E_OBJECT_CHECK_RETURN(ec, EINA_TRUE);
3284    return ec->internal;
3285 }
3286
3287 EINTERN void
3288 e_client_desk_iconify_skip_set(E_Client *ec, Eina_Bool skip)
3289 {
3290    if (!ec) return;
3291    ec->user_skip_winlist = skip;
3292 }
3293
3294 EINTERN Eina_Bool
3295 e_client_desk_iconify_skip_get(E_Client *ec)
3296 {
3297    if (!ec) return EINA_FALSE;
3298    return ec->user_skip_winlist;
3299 }
3300
3301 EINTERN Eina_Bool
3302 e_client_comp_grabbed_get(void)
3303 {
3304    return comp_grabbed;
3305 }
3306
3307 EINTERN E_Client *
3308 e_client_action_get(void)
3309 {
3310    return action_client;
3311 }
3312
3313
3314 //////////////////////////////////////////////////////////
3315
3316 EINTERN void
3317 e_client_mouse_in(E_Client *ec, int x, int y)
3318 {
3319    E_Desk *desk;
3320
3321    if (comp_grabbed) return;
3322    if (e_object_is_del(E_OBJECT(ec))) return;
3323    desk = e_comp_desk_find_by_ec(ec);
3324    if (desk && desk->animate_count) return;
3325    ec->mouse.current.mx = x;
3326    ec->mouse.current.my = y;
3327    ec->mouse.in = 1;
3328
3329    wl_signal_emit_mutable(&PRI(ec)->events.mouse_in, NULL);
3330 }
3331
3332 EINTERN void
3333 e_client_mouse_out(E_Client *ec, int x, int y)
3334 {
3335    E_Desk *desk;
3336
3337    if (comp_grabbed) return;
3338    if (ec->fullscreen) return;
3339    if (e_object_is_del(E_OBJECT(ec))) return;
3340    desk = e_comp_desk_find_by_ec(ec);
3341    if (desk && desk->animate_count) return;
3342
3343    ec->mouse.current.mx = x;
3344    ec->mouse.current.my = y;
3345    ec->mouse.in = 0;
3346
3347    wl_signal_emit_mutable(&PRI(ec)->events.mouse_out, NULL);
3348 }
3349
3350 EINTERN void
3351 e_client_mouse_wheel(E_Client *ec, Evas_Point *output, E_Binding_Event_Wheel *ev)
3352 {
3353    EINA_SAFETY_ON_NULL_RETURN(ec);
3354    if (action_client) return;
3355    ec->mouse.current.mx = output->x;
3356    ec->mouse.current.my = output->y;
3357 }
3358
3359 EINTERN void
3360 e_client_mouse_down(E_Client *ec, int button, Evas_Point *output, E_Binding_Event_Mouse_Button *ev)
3361 {
3362    EINA_SAFETY_ON_NULL_RETURN(ec);
3363
3364    if (action_client || ec->iconic || e_client_util_ignored_get(ec)) return;
3365    if ((button >= 1) && (button <= 3))
3366      {
3367         ec->mouse.last_down[button - 1].mx = output->x;
3368         ec->mouse.last_down[button - 1].my = output->y;
3369         ec->mouse.last_down[button - 1].x = ec->x;
3370         ec->mouse.last_down[button - 1].y = ec->y;
3371         ec->mouse.last_down[button - 1].w = ec->w;
3372         ec->mouse.last_down[button - 1].h = ec->h;
3373      }
3374    else
3375      {
3376         ec->moveinfo.down.x = ec->x;
3377         ec->moveinfo.down.y = ec->y;
3378         ec->moveinfo.down.w = ec->w;
3379         ec->moveinfo.down.h = ec->h;
3380      }
3381    ec->mouse.current.mx = output->x;
3382    ec->mouse.current.my = output->y;
3383    if ((button >= 1) && (button <= 3))
3384      {
3385         ec->mouse.last_down[button - 1].mx = output->x;
3386         ec->mouse.last_down[button - 1].my = output->y;
3387         ec->mouse.last_down[button - 1].x = ec->x;
3388         ec->mouse.last_down[button - 1].y = ec->y;
3389         ec->mouse.last_down[button - 1].w = ec->w;
3390         ec->mouse.last_down[button - 1].h = ec->h;
3391      }
3392    else
3393      {
3394         ec->moveinfo.down.x = ec->x;
3395         ec->moveinfo.down.y = ec->y;
3396         ec->moveinfo.down.w = ec->w;
3397         ec->moveinfo.down.h = ec->h;
3398      }
3399    ec->mouse.current.mx = output->x;
3400    ec->mouse.current.my = output->y;
3401
3402    wl_signal_emit_mutable(&PRI(ec)->events.mouse_down, NULL);
3403 }
3404
3405 EINTERN void
3406 e_client_mouse_up(E_Client *ec, int button, Evas_Point *output, E_Binding_Event_Mouse_Button* ev)
3407 {
3408    EINA_SAFETY_ON_NULL_RETURN(ec);
3409    if (ec->iconic || e_client_util_ignored_get(ec)) return;
3410    if ((button >= 1) && (button <= 3))
3411      {
3412         ec->mouse.last_up[button - 1].mx = output->x;
3413         ec->mouse.last_up[button - 1].my = output->y;
3414         ec->mouse.last_up[button - 1].x = ec->x;
3415         ec->mouse.last_up[button - 1].y = ec->y;
3416      }
3417    ec->mouse.current.mx = output->x;
3418    ec->mouse.current.my = output->y;
3419    /* also we don't pass the same params that went in - then again that */
3420    /* should be ok as we are just ending the action if it has an end */
3421    if (ec->cur_mouse_action)
3422      {
3423         if (ec->cur_mouse_action->func.end_mouse)
3424           ec->cur_mouse_action->func.end_mouse(E_OBJECT(ec), "", ev);
3425         else if (ec->cur_mouse_action->func.end)
3426           ec->cur_mouse_action->func.end(E_OBJECT(ec), "");
3427         e_object_unref(E_OBJECT(ec->cur_mouse_action));
3428         ec->cur_mouse_action = NULL;
3429      }
3430
3431    if ((button >= 1) && (button <= 3))
3432      {
3433         ec->mouse.last_up[button - 1].mx = output->x;
3434         ec->mouse.last_up[button - 1].my = output->y;
3435         ec->mouse.last_up[button - 1].x = ec->x;
3436         ec->mouse.last_up[button - 1].y = ec->y;
3437      }
3438 }
3439
3440 E_API void
3441 e_client_stay_within_canvas_margin(E_Client *ec)
3442 {
3443    int new_x = ec->x;
3444    int new_y = ec->y;
3445
3446    if (ec->floating)
3447      {
3448         _e_client_stay_within_canvas_margin(ec, ec->x, ec->y, &new_x, &new_y);
3449
3450         if ((ec->x != new_x) || (ec->y != new_y))
3451           evas_object_move(ec->frame, new_x, new_y);
3452      }
3453 }
3454
3455 EINTERN void
3456 e_client_mouse_move(E_Client *ec, Evas_Point *output)
3457 {
3458    EINA_SAFETY_ON_NULL_RETURN(ec);
3459    if (ec->iconic || e_client_util_ignored_get(ec)) return;
3460    ec->mouse.current.mx = output->x;
3461    ec->mouse.current.my = output->y;
3462    if (e_client_util_moving_get(ec))
3463      {
3464         _e_client_move_handle(ec);
3465      }
3466    else if (e_client_util_resizing_get(ec))
3467      {
3468         _e_client_resize_handle(ec);
3469      }
3470 }
3471 ///////////////////////////////////////////////////////
3472
3473 EINTERN void
3474 e_client_res_change_geometry_save(E_Client *ec)
3475 {
3476    E_OBJECT_CHECK(ec);
3477    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
3478
3479    if (ec->pre_res_change.valid) return;
3480    ec->pre_res_change.valid = 1;
3481    ec->pre_res_change.x = ec->x;
3482    ec->pre_res_change.y = ec->y;
3483    ec->pre_res_change.w = ec->w;
3484    ec->pre_res_change.h = ec->h;
3485    ec->pre_res_change.saved.x = ec->saved.x;
3486    ec->pre_res_change.saved.y = ec->saved.y;
3487    ec->pre_res_change.saved.w = ec->saved.w;
3488    ec->pre_res_change.saved.h = ec->saved.h;
3489 }
3490
3491 EINTERN void
3492 e_client_res_change_geometry_restore(E_Client *ec)
3493 {
3494    E_Zone *zone;
3495
3496    struct
3497    {
3498       unsigned char valid : 1;
3499       int           x, y, w, h;
3500       struct
3501       {
3502          int x, y, w, h;
3503       } saved;
3504    } pre_res_change;
3505
3506    E_OBJECT_CHECK(ec);
3507    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
3508    if (!ec->pre_res_change.valid) return;
3509    if (ec->new_client) return;
3510
3511    zone = e_comp_zone_find_by_ec(ec);
3512    if (!zone) return;
3513
3514    memcpy(&pre_res_change, &ec->pre_res_change, sizeof(pre_res_change));
3515
3516    if (ec->fullscreen)
3517      {
3518         e_client_unfullscreen(ec);
3519         e_client_fullscreen(ec, e_config->fullscreen_policy);
3520      }
3521    else if (ec->maximized != E_MAXIMIZE_NONE)
3522      {
3523         E_Maximize max;
3524
3525         max = ec->maximized;
3526         e_client_unmaximize(ec, E_MAXIMIZE_BOTH);
3527         e_client_maximize(ec, max);
3528      }
3529    else
3530      {
3531         int x, y, w, h, zx, zy, zw, zh;
3532
3533         ec->saved.x = ec->pre_res_change.saved.x;
3534         ec->saved.y = ec->pre_res_change.saved.y;
3535         ec->saved.w = ec->pre_res_change.saved.w;
3536         ec->saved.h = ec->pre_res_change.saved.h;
3537
3538         e_zone_useful_geometry_get(zone, &zx, &zy, &zw, &zh);
3539
3540         if (ec->saved.w > zw)
3541           ec->saved.w = zw;
3542         if ((ec->saved.x + ec->saved.w) > (zx + zw))
3543           ec->saved.x = zx + zw - ec->saved.w;
3544
3545         if (ec->saved.h > zh)
3546           ec->saved.h = zh;
3547         if ((ec->saved.y + ec->saved.h) > (zy + zh))
3548           ec->saved.y = zy + zh - ec->saved.h;
3549
3550         x = ec->pre_res_change.x;
3551         y = ec->pre_res_change.y;
3552         w = ec->pre_res_change.w;
3553         h = ec->pre_res_change.h;
3554         if (w > zw)
3555           w = zw;
3556         if (h > zh)
3557           h = zh;
3558         if ((x + w) > (zx + zw))
3559           x = zx + zw - w;
3560         if ((y + h) > (zy + zh))
3561           y = zy + zh - h;
3562         evas_object_geometry_set(ec->frame, x, y, w, h);
3563      }
3564    memcpy(&ec->pre_res_change, &pre_res_change, sizeof(pre_res_change));
3565 }
3566
3567 EINTERN void
3568 e_client_pos_set(E_Client *ec, int x, int y)
3569 {
3570    if (!ec) return;
3571    ec->x = x;
3572    ec->y = y;
3573 }
3574
3575 EINTERN void
3576 e_client_pos_get(E_Client *ec, int *x, int *y)
3577 {
3578    int ex = 0;
3579    int ey = 0;
3580
3581    if (ec)
3582      {
3583         ex = ec->x;
3584         ey = ec->y;
3585      }
3586
3587    if (x) *x = ex;
3588    if (y) *y = ey;
3589 }
3590
3591 E_API void
3592 e_client_size_set(E_Client *ec, int w, int h)
3593 {
3594    if (!ec) return;
3595    ec->w = w;
3596    ec->h = h;
3597 }
3598
3599 E_API void
3600 e_client_size_get(E_Client *ec, int *w, int *h)
3601 {
3602    int ew = 0;
3603    int eh = 0;
3604
3605    if (ec)
3606      {
3607         ew = ec->w;
3608         eh = ec->h;
3609      }
3610
3611    if (w) *w = ew;
3612    if (h) *h = eh;
3613 }
3614
3615 E_API void
3616 e_client_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
3617 {
3618    int gx = 0;
3619    int gy = 0;
3620    int gw = 0;
3621    int gh = 0;
3622
3623    E_OBJECT_CHECK(ec);
3624    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
3625
3626    if (e_client_transform_core_enable_get(ec))
3627      {
3628         gx = ec->transform_core.result.boundary.x;
3629         gy = ec->transform_core.result.boundary.y;
3630         gw = ec->transform_core.result.boundary.w;
3631         gh = ec->transform_core.result.boundary.h;
3632      }
3633    else
3634      {
3635         if (ec->frame)
3636           {
3637              evas_object_geometry_get(ec->frame, &gx, &gy, &gw, &gh);
3638              if (gw == 0 && gh == 0)
3639                {
3640                   /* In this case, there is no image buffer in e_comp_object, thus it
3641                    * should return geometry value of ec itself. It usually happens if
3642                    * new ec is not mapped yet.
3643                    */
3644                   gw = ec->w;
3645                   gh = ec->h;
3646                   gx = ec->x;
3647                   gy = ec->y;
3648                }
3649           }
3650         else
3651           {
3652              gx = ec->x;
3653              gy = ec->y;
3654              gw = ec->w;
3655              gh = ec->h;
3656           }
3657      }
3658
3659    if (x) *x = gx;
3660    if (y) *y = gy;
3661    if (w) *w = gw;
3662    if (h) *h = gh;
3663 }
3664
3665 E_API E_Client *
3666 e_client_above_get(const E_Client *ec)
3667 {
3668 #ifdef REFACTOR_DESK_AREA
3669    E_Client_Data_Get_Above data;
3670
3671    E_OBJECT_CHECK_RETURN(ec, NULL);
3672    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3673
3674    data.above_ec = NULL;
3675
3676    wl_signal_emit_mutable(&PRI(ec)->events.get_above, &data);
3677
3678    return data.above_ec;
3679 #else
3680    unsigned int x;
3681    E_Client *ec2;
3682
3683    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
3684    if (EINA_INLIST_GET(ec)->next) //check current layer
3685      {
3686         EINA_INLIST_FOREACH(EINA_INLIST_GET(ec)->next, ec2)
3687           {
3688              if (ec == ec2)
3689                {
3690                   ELOGF("FATAL", "CHECK the ec inlist next", ec);
3691                   continue;
3692                }
3693              if (!e_object_is_del(E_OBJECT(ec2)))
3694                return ec2;
3695           }
3696      }
3697    if (ec->layer == E_LAYER_CLIENT_CURSOR) return NULL;
3698    if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return NULL;
3699
3700    g_rec_mutex_lock(&e_comp->ec_list_mutex);
3701    /* go up the layers until we find one */
3702    for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
3703      {
3704         if (!e_comp->layers[x].clients) continue;
3705         EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
3706           {
3707              if (ec == ec2)
3708                {
3709                   ELOGF("FATAL", "EC exist above layer. ec layer_map:%d, cur layer_map:%d",
3710                         ec, e_comp_canvas_layer_map(ec->layer), x);
3711                   continue;
3712                }
3713              if (!e_object_is_del(E_OBJECT(ec2)))
3714                {
3715                   g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3716                   return ec2;
3717                }
3718           }
3719      }
3720    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3721
3722    return NULL;
3723 #endif
3724 }
3725
3726 E_API E_Client *
3727 e_client_below_get(const E_Client *ec)
3728 {
3729 #ifdef REFACTOR_DESK_AREA
3730    E_Client_Data_Get_Below data;
3731
3732    E_OBJECT_CHECK_RETURN(ec, NULL);
3733    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3734
3735    data.below_ec = NULL;
3736
3737    wl_signal_emit_mutable(&PRI(ec)->events.get_below, &data);
3738
3739    return data.below_ec;
3740 #else
3741    unsigned int x;
3742    E_Client *ec2;
3743    Eina_Inlist *l;
3744    E_Layer ec_layer, ec_layer_cw;
3745    int cw_layer;
3746
3747    E_OBJECT_CHECK_RETURN(ec, NULL);
3748    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3749
3750    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
3751    if (EINA_INLIST_GET(ec)->prev) //check current layer
3752      {
3753         for (l = EINA_INLIST_GET(ec)->prev; l; l = l->prev)
3754           {
3755              ec2 = EINA_INLIST_CONTAINER_GET(l, E_Client);
3756              if (ec == ec2)
3757                {
3758                   ELOGF("FATAL", "CHECK the ec inlist prev", ec);
3759                   continue;
3760                }
3761              if (!e_object_is_del(E_OBJECT(ec2)))
3762                return ec2;
3763           }
3764      }
3765
3766    // check layer validation
3767    ec_layer = ec->layer;
3768    if (ec->layer_block || ec->layer_pending)
3769      {
3770         cw_layer = e_comp_object_layer_get(ec->frame);
3771         if (cw_layer >= 0)
3772           {
3773              ec_layer_cw = e_comp_canvas_layer_map_to(cw_layer);
3774              if (ec_layer != ec_layer_cw)
3775                {
3776                   ELOGF("COMP", "LAYER is not same. USE obj layer! (ec->layer:%d, obj:%d). block:%d, pending:%d)", ec, ec_layer, ec_layer_cw, ec->layer_block, ec->layer_pending);
3777                   ec_layer = ec_layer_cw;
3778                }
3779           }
3780      }
3781
3782    if (ec_layer == E_LAYER_CLIENT_DESKTOP) return NULL;
3783    if (e_comp_canvas_client_layer_map(ec_layer) == 9999) return NULL;
3784
3785    /* go down the layers until we find one */
3786    x = e_comp_canvas_layer_map(ec_layer);
3787    if (x > 0) x--;
3788
3789    g_rec_mutex_lock(&e_comp->ec_list_mutex);
3790    for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
3791      {
3792         if (!e_comp->layers[x].clients) continue;
3793         EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
3794           {
3795              if (ec == ec2)
3796                {
3797                   ELOGF("FATAL", "EC exist below layer. ec layer_map:%d, cur layer_map:%d",
3798                         ec, e_comp_canvas_layer_map(ec_layer), x);
3799                   continue;
3800                }
3801              if (!e_object_is_del(E_OBJECT(ec2)))
3802                {
3803                   g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3804                   return ec2;
3805                }
3806           }
3807      }
3808    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3809
3810    return NULL;
3811 #endif
3812 }
3813
3814 EINTERN E_Client *
3815 e_client_visible_above_get(E_Client *ec)
3816 {
3817 #ifdef REFACTOR_DESK_AREA
3818    E_Client_Data_Get_Visible_Above data;
3819
3820    E_OBJECT_CHECK_RETURN(ec, NULL);
3821    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3822
3823    data.above_ec = NULL;
3824
3825    wl_signal_emit_mutable(&PRI(ec)->events.get_visible_above, &data);
3826
3827    return data.above_ec;
3828 #else
3829    unsigned int x;
3830    E_Client *ec2;
3831
3832    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
3833    if (EINA_INLIST_GET(ec)->next) //check current layer
3834      {
3835         EINA_INLIST_FOREACH(EINA_INLIST_GET(ec)->next, ec2)
3836           {
3837              if (ec == ec2) continue;
3838              if ((!e_object_is_del(E_OBJECT(ec2))) &&
3839                  (!e_client_util_ignored_get(ec2)) &&
3840                  (ec2->visible) &&
3841                  (ec2->frame))
3842                return ec2;
3843           }
3844      }
3845
3846    if (ec->layer == E_LAYER_CLIENT_CURSOR) return NULL;
3847    if (e_comp_canvas_client_layer_map(ec->layer) == 9999) return NULL;
3848
3849    /* go up the layers until we find one */
3850    for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
3851      {
3852         if (!e_comp->layers[x].clients) continue;
3853         EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
3854           {
3855              if (ec == ec2) continue;
3856              if ((!e_object_is_del(E_OBJECT(ec2))) &&
3857                  (!e_client_util_ignored_get(ec2)) &&
3858                  (ec2->visible) &&
3859                  (ec2->frame))
3860                return ec2;
3861           }
3862      }
3863
3864    return NULL;
3865 #endif
3866 }
3867
3868 EINTERN E_Client *
3869 e_client_visible_below_get(E_Client *ec)
3870 {
3871 #ifdef REFACTOR_DESK_AREA
3872    E_Client_Data_Get_Visible_Below data;
3873
3874    E_OBJECT_CHECK_RETURN(ec, NULL);
3875    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3876
3877    data.below_ec = NULL;
3878
3879    wl_signal_emit_mutable(&PRI(ec)->events.get_visible_below, &data);
3880
3881    return data.below_ec;
3882 #else
3883    unsigned int x;
3884    E_Client *ec2;
3885    Eina_Inlist *l;
3886    E_Layer ec_layer, ec_layer_cw;
3887    int cw_layer;
3888
3889    E_OBJECT_CHECK_RETURN(ec, NULL);
3890    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, NULL);
3891
3892    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
3893    if (EINA_INLIST_GET(ec)->prev) //check current layer
3894      {
3895         for (l = EINA_INLIST_GET(ec)->prev; l; l = l->prev)
3896           {
3897              ec2 = EINA_INLIST_CONTAINER_GET(l, E_Client);
3898              if (ec == ec2) continue;
3899              if ((!e_object_is_del(E_OBJECT(ec2))) &&
3900                  (!e_client_util_ignored_get(ec2)) &&
3901                  (ec2->visible) &&
3902                  (ec2->frame))
3903                return ec2;
3904           }
3905      }
3906
3907    // check layer validation
3908    ec_layer = ec->layer;
3909    if (ec->layer_block || ec->layer_pending)
3910      {
3911         cw_layer = e_comp_object_layer_get(ec->frame);
3912         if (cw_layer >= 0)
3913           {
3914              ec_layer_cw = e_comp_canvas_layer_map_to(cw_layer);
3915              if (ec_layer != ec_layer_cw)
3916                {
3917                   ELOGF("COMP", "LAYER is not same. USE obj layer! (ec->layer:%d, obj:%d). block:%d, pending:%d)", ec, ec_layer, ec_layer_cw, ec->layer_block, ec->layer_pending);
3918                   ec_layer = ec_layer_cw;
3919                }
3920           }
3921      }
3922
3923    /* go down the layers until we find one */
3924    if (e_comp_canvas_layer_map(ec->layer) > e_comp_canvas_layer_map(E_LAYER_MAX)) return NULL;
3925    x = e_comp_canvas_layer_map(ec->layer);
3926    if (x > 0) x--;
3927
3928    for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
3929      {
3930         if (!e_comp->layers[x].clients) continue;
3931         EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
3932           {
3933              if (ec == ec2) continue;
3934              if ((!e_object_is_del(E_OBJECT(ec2))) &&
3935                  (!e_client_util_ignored_get(ec2)) &&
3936                  (ec2->visible) &&
3937                  (ec2->frame))
3938                return ec2;
3939           }
3940      }
3941
3942    return NULL;
3943 #endif
3944 }
3945
3946 E_API E_Client *
3947 e_client_bottom_get(void)
3948 {
3949 #ifdef REFACTOR_DESK_AREA
3950    E_Zone *zone;
3951    E_Desk *desk;
3952
3953    // get the bottom ec from current desk at current zone
3954    zone = e_zone_current_get();
3955    desk = e_desk_current_get(zone);
3956
3957    return e_desk_bottom_ec_get(desk);
3958 #else
3959    unsigned int x;
3960    g_rec_mutex_lock(&e_comp->ec_list_mutex);
3961    for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
3962      {
3963         E_Client *ec2;
3964
3965         if (!e_comp->layers[x].clients) continue;
3966         EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
3967           if (!e_object_is_del(E_OBJECT(ec2)))
3968             {
3969                g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3970                return ec2;
3971             }
3972      }
3973    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
3974
3975    return NULL;
3976 #endif
3977 }
3978
3979 E_API E_Client *
3980 e_client_top_get(void)
3981 {
3982 #ifdef REFACTOR_DESK_AREA
3983    E_Zone *zone;
3984    E_Desk *desk;
3985
3986    // get the top ec from current desk at current zone
3987    zone = e_zone_current_get();
3988    desk = e_desk_current_get(zone);
3989
3990    return e_desk_top_ec_get(desk);
3991 #else
3992    unsigned int x;
3993    g_rec_mutex_lock(&e_comp->ec_list_mutex);
3994    for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
3995      {
3996         E_Client *ec2;
3997
3998         if (!e_comp->layers[x].clients) continue;
3999         EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
4000           if (!e_object_is_del(E_OBJECT(ec2)))
4001             {
4002                g_rec_mutex_unlock(&e_comp->ec_list_mutex);
4003                return ec2;
4004             }
4005      }
4006    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
4007
4008    return NULL;
4009 #endif
4010 }
4011
4012 EINTERN unsigned int
4013 e_clients_count(void)
4014 {
4015    return eina_list_count(e_comp->clients);
4016 }
4017
4018
4019 /**
4020  * Set a callback which will be called just prior to updating the
4021  * move coordinates for a border
4022  */
4023 EINTERN void
4024 e_client_move_intercept_cb_set(E_Client *ec, E_Client_Move_Intercept_Cb cb)
4025 {
4026    ec->move_intercept_cb = cb;
4027 }
4028
4029 ///////////////////////////////////////
4030
4031 E_API E_Client_Hook *
4032 e_client_hook_add(E_Client_Hook_Point hookpoint, E_Client_Hook_Cb func, const void *data)
4033 {
4034    E_Client_Hook *ch;
4035
4036    EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_CLIENT_HOOK_LAST, NULL);
4037    ch = E_NEW(E_Client_Hook, 1);
4038    if (!ch) return NULL;
4039    ch->hookpoint = hookpoint;
4040    ch->func = func;
4041    ch->data = (void*)data;
4042    _e_client_hooks[hookpoint] = eina_inlist_append(_e_client_hooks[hookpoint], EINA_INLIST_GET(ch));
4043    return ch;
4044 }
4045
4046 E_API void
4047 e_client_hook_del(E_Client_Hook *ch)
4048 {
4049    ch->delete_me = 1;
4050    if (_e_client_hooks_walking == 0)
4051      {
4052         _e_client_hooks[ch->hookpoint] = eina_inlist_remove(_e_client_hooks[ch->hookpoint], EINA_INLIST_GET(ch));
4053         free(ch);
4054      }
4055    else
4056      _e_client_hooks_delete++;
4057 }
4058
4059 ///////////////////////////////////////
4060
4061 E_API E_Client_Intercept_Hook *
4062 e_client_intercept_hook_add(E_Client_Intercept_Hook_Point hookpoint, E_Client_Intercept_Hook_Cb func, const void *data)
4063 {
4064    E_Client_Intercept_Hook *ch;
4065
4066    EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_CLIENT_INTERCEPT_HOOK_LAST, NULL);
4067    ch = E_NEW(E_Client_Intercept_Hook, 1);
4068    if (!ch) return NULL;
4069    ch->hookpoint = hookpoint;
4070    ch->func = func;
4071    ch->data = (void*)data;
4072    _e_client_intercept_hooks[hookpoint] = eina_inlist_append(_e_client_intercept_hooks[hookpoint], EINA_INLIST_GET(ch));
4073    return ch;
4074 }
4075
4076 E_API void
4077 e_client_intercept_hook_del(E_Client_Intercept_Hook *ch)
4078 {
4079    if (!ch) return;
4080
4081    ch->delete_me = 1;
4082    if (_e_client_intercept_hooks_walking == 0)
4083      {
4084         _e_client_intercept_hooks[ch->hookpoint] =
4085            eina_inlist_remove(_e_client_intercept_hooks[ch->hookpoint], EINA_INLIST_GET(ch));
4086         free(ch);
4087      }
4088    else
4089      _e_client_intercept_hooks_delete++;
4090 }
4091
4092 E_API void
4093 e_client_focus_latest_set(E_Client *ec)
4094 {
4095    EINA_SAFETY_ON_NULL_RETURN(ec);
4096
4097    wl_signal_emit_mutable(&PRI(ec)->events.focus_latest_set, NULL);
4098 }
4099
4100 E_API void
4101 e_client_focus_defer_set(E_Client *ec)
4102 {
4103    EINA_SAFETY_ON_NULL_RETURN(ec);
4104
4105    wl_signal_emit_mutable(&PRI(ec)->events.focus_defer_set, NULL);
4106 }
4107
4108 EINTERN void
4109 e_client_focused_set(E_Client *ec)
4110 {
4111    E_Client *focused_ec;
4112    E_Zone *zone;
4113
4114    if (ec)
4115      ELOGF("FOCUS", "CLIENT FOCUSED_SET : SET", ec);
4116    else
4117      ELOGF("FOCUS", "CLIENT FOCUSED_SET : UNSET", NULL);
4118
4119   focused_ec = e_comp_focused_ec_get();
4120   if (ec == focused_ec) return;
4121
4122    TRACE_DS_BEGIN(CLIENT:FOCUSED SET);
4123
4124    // unset the current focused_ec if focused_ec is not being deleted
4125    if (focused_ec)
4126      {
4127        if (!e_object_is_del(E_OBJECT(focused_ec)))
4128          {
4129             // FIXME: Remove focus_unset event of client.
4130             //        Instead, make zone focus_unset event and use it.
4131             wl_signal_emit_mutable(&PRI(focused_ec)->events.focus_unset, NULL);
4132             _e_client_hook_call(E_CLIENT_HOOK_FOCUS_UNSET, focused_ec);
4133
4134             if (e_object_ref_get(E_OBJECT(focused_ec)) > 0)
4135               {
4136                  _e_client_event_simple(focused_ec, E_EVENT_CLIENT_FOCUS_OUT);
4137               }
4138          }
4139      }
4140
4141    // clear the current focused_ec when ec is NULL
4142    if (!ec)
4143      {
4144         zone = e_comp_zone_find_by_ec(focused_ec);
4145         e_zone_focus_clear(zone);
4146         TRACE_DS_END();
4147         return;
4148      }
4149
4150    // FIXME: Remove focus_set event of client.
4151    //        Instead, make zone focus_set event and use it.
4152    // set the new current focused_ec
4153    wl_signal_emit_mutable(&PRI(ec)->events.focus_set, NULL);
4154    _e_client_hook_call(E_CLIENT_HOOK_FOCUS_SET, ec);
4155
4156    // send the client_focuse_in event
4157    _e_client_event_simple(ec, E_EVENT_CLIENT_FOCUS_IN);
4158
4159    TRACE_DS_END();
4160 }
4161
4162 EINTERN void
4163 e_client_activate(E_Client *ec)
4164 {
4165    E_OBJECT_CHECK(ec);
4166    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4167
4168    TRACE_DS_BEGIN(CLIENT:ACTIVATE);
4169
4170    ELOGF("COMP", "Set launching flag..", ec);
4171    ec->launching = EINA_TRUE;
4172
4173    ec->exp_iconify.not_raise = 0;
4174
4175    if (ec->iconic)
4176      {
4177          if (!ec->lock_user_iconify)
4178            e_client_uniconify(ec);
4179      }
4180    ELOGF("COMP", "Un-Set ICONIFY BY CLIENT", ec);
4181    ec->exp_iconify.by_client = 0;
4182    e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
4183
4184    wl_signal_emit_mutable(&PRI(ec)->events.activate_done, NULL);
4185    _e_client_hook_call(E_CLIENT_HOOK_ACTIVATE_DONE, ec);
4186
4187    TRACE_DS_END();
4188 }
4189
4190 E_API E_Client *
4191 e_client_focused_get(void)
4192 {
4193    return e_comp_focused_ec_get();
4194 }
4195
4196 EINTERN Eina_List *
4197 e_client_lost_windows_get(E_Zone *zone)
4198 {
4199    Eina_List *list = NULL;
4200    const Eina_List *l;
4201    E_Client *ec;
4202    int loss_overlap = 5;
4203
4204    E_OBJECT_CHECK_RETURN(zone, NULL);
4205    E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
4206    EINA_LIST_FOREACH(e_comp->clients, l, ec)
4207      {
4208         if (!e_zone_has_ec(zone, ec)) continue;
4209         if (e_client_util_ignored_get(ec)) continue;
4210
4211         if (!E_INTERSECTS(zone->x + loss_overlap,
4212                           zone->y + loss_overlap,
4213                           zone->w - (2 * loss_overlap),
4214                           zone->h - (2 * loss_overlap),
4215                           ec->x, ec->y, ec->w, ec->h))
4216           {
4217              list = eina_list_append(list, ec);
4218           }
4219      }
4220    return list;
4221 }
4222
4223 ///////////////////////////////////////
4224
4225 EINTERN void
4226 e_client_maximized_geometry_set(E_Client *ec, int x, int y, int w, int h)
4227 {
4228    if (!ec) return;
4229
4230    ec->maximized_info.x = x;
4231    ec->maximized_info.y = y;
4232    ec->maximized_info.w = w;
4233    ec->maximized_info.h = h;
4234
4235    e_client_frame_geometry_set(ec, x, y, w, h);
4236 }
4237
4238 EINTERN void
4239 e_client_maximized_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
4240 {
4241    if (!ec) return;
4242
4243    if (x) *x = ec->maximized_info.x;
4244    if (y) *y = ec->maximized_info.y;
4245    if (w) *w = ec->maximized_info.w;
4246    if (h) *h = ec->maximized_info.h;
4247 }
4248
4249 EINTERN void
4250 e_client_maximize_update(E_Client *ec)
4251 {
4252    E_Maximize max;
4253
4254    E_OBJECT_CHECK(ec);
4255    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4256
4257    if (ec->maximized)
4258      {
4259         max = ec->maximized;
4260         ec->maximized = 0;
4261         e_client_maximize(ec, max);
4262      }
4263 }
4264
4265 E_API void
4266 e_client_maximize(E_Client *ec, E_Maximize max)
4267 {
4268    E_OBJECT_CHECK(ec);
4269    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4270
4271    if (!(max & E_MAXIMIZE_DIRECTION)) max |= E_MAXIMIZE_BOTH;
4272
4273    if ((ec->maximized & E_MAXIMIZE_DIRECTION) == (max & E_MAXIMIZE_DIRECTION))
4274      {
4275         if ((ec->maximized & E_MAXIMIZE_TYPE) == (max & E_MAXIMIZE_TYPE))
4276           return;
4277      }
4278
4279    if (ec->new_client)
4280      {
4281         ec->changes.need_maximize = 1;
4282         ec->maximized &= ~E_MAXIMIZE_TYPE;
4283         ec->maximized |= max;
4284         EC_CHANGED(ec);
4285         return;
4286      }
4287
4288    if (!ec->fullscreen)
4289      {
4290         // call the maximize hook of a client
4291         wl_signal_emit_mutable(&PRI(ec)->events.maximize, &max);
4292
4293         // store the E_Maximize value
4294         ec->maximized = max;
4295         ec->changes.need_unmaximize = 0;
4296
4297         evas_object_smart_callback_call(ec->frame, "maximize_done", NULL);
4298      }
4299    else
4300      {
4301         // store the E_Maximize value
4302         ec->maximized = max;
4303         ec->changes.need_unmaximize = 0;
4304      }
4305 }
4306
4307 E_API void
4308 e_client_unmaximize(E_Client *ec, E_Maximize max)
4309 {
4310    E_OBJECT_CHECK(ec);
4311    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4312
4313    if (!(max & E_MAXIMIZE_DIRECTION))
4314      {
4315         CRI("BUG: Unmaximize call without direction!");
4316         return;
4317      }
4318    if (ec->new_client)
4319      {
4320         ec->changes.need_unmaximize = 1;
4321         EC_CHANGED(ec);
4322         return;
4323      }
4324
4325    /* Remove directions not used */
4326    max &= (ec->maximized & E_MAXIMIZE_DIRECTION);
4327    /* Can only remove existing maximization directions */
4328    if (!max) return;
4329
4330    if (!ec->fullscreen)
4331      {
4332         evas_object_smart_callback_call(ec->frame, "unmaximize_pre", NULL);
4333
4334         // call the unmaximize hook of a client
4335         wl_signal_emit_mutable(&PRI(ec)->events.unmaximize, &max);
4336
4337         evas_object_smart_callback_call(ec->frame, "unmaximize_done", NULL);
4338      }
4339
4340    ec->maximized = E_MAXIMIZE_NONE;
4341    ec->changes.need_unmaximize = 0;
4342 }
4343
4344 EINTERN void
4345 e_client_fullscreen(E_Client *ec, E_Fullscreen policy)
4346 {
4347    E_OBJECT_CHECK(ec);
4348    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4349
4350    if (ec->fullscreen) return;
4351
4352    // call the fullscreen_pre hook of a client
4353    wl_signal_emit_mutable(&PRI(ec)->events.fullscreen_pre, NULL);
4354    _e_client_hook_call(E_CLIENT_HOOK_FULLSCREEN_PRE, ec);
4355
4356    if (ec->skip_fullscreen) return;
4357    if (ec->new_client)
4358      {
4359         ec->need_fullscreen = 1;
4360         return;
4361      }
4362
4363    ec->saved.layer = ec->layer;
4364    e_client_layer_set(ec, ec->fullscreen_layer);
4365
4366    ec->fullscreen = 1;
4367
4368    // call the fullscreen hook of a client
4369    wl_signal_emit_mutable(&PRI(ec)->events.fullscreen, &policy);
4370
4371    ec->fullscreen_policy = policy;
4372
4373    _e_client_event_simple(ec, E_EVENT_CLIENT_FULLSCREEN);
4374 }
4375
4376 EINTERN void
4377 e_client_unfullscreen(E_Client *ec)
4378 {
4379    E_OBJECT_CHECK(ec);
4380    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4381
4382    ec->need_fullscreen = 0;
4383
4384    if (!ec->fullscreen) return;
4385
4386    ec->fullscreen = 0;
4387
4388    E_Fullscreen policy = ec->fullscreen_policy;
4389
4390    // call the unfullscreen hook of a client
4391    wl_signal_emit_mutable(&PRI(ec)->events.unfullscreen, &policy);
4392
4393    e_client_layer_set(ec, ec->saved.layer);
4394
4395    ec->fullscreen_policy = E_FULLSCREEN_RESIZE;
4396
4397    _e_client_event_simple(ec, E_EVENT_CLIENT_UNFULLSCREEN);
4398 }
4399
4400 ///////////////////////////////////////
4401 EINTERN Eina_Bool
4402 e_client_is_parent_iconify_by_client(E_Client *ec)
4403 {
4404    E_Client *parent = ec->parent;
4405    if (!parent) return EINA_FALSE;
4406
4407    if ((parent->exp_iconify.type == E_ICONIFIED_TYPE_ICONIFY_BY_CLIENT) ||
4408        (parent->exp_iconify.type == E_ICONIFIED_TYPE_PARENT_ICONIFY_BY_CLIENT))
4409      return EINA_TRUE;
4410
4411    return EINA_FALSE;
4412 }
4413
4414 E_API void
4415 e_client_iconify(E_Client *ec)
4416 {
4417    E_OBJECT_CHECK(ec);
4418    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4419
4420    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
4421    Eina_Bool iconified_by_client = e_client_is_iconified_by_client(ec);
4422
4423    ELOGF("TZVIS", "ICONIFY  |iconic:%d  |argb:%d       |not_raise:%d   |by_client:%d, type:%d",
4424          ec, ec->iconic, ec->argb, (unsigned int)ec->exp_iconify.not_raise,
4425          ec->exp_iconify.by_client, ec->exp_iconify.type);
4426
4427    if (ec->iconic) return;
4428    if (ec->exp_iconify.skip_iconify && !iconified_by_client) return;
4429    if (ec->exp_iconify.skip_by_remote) return;
4430    if (!cdata || !cdata->mapped)
4431      {
4432         if (!iconified_by_client)
4433           {
4434              ELOGF("TZVIS", "Not mapped.. So, don't iconify", ec);
4435              return;
4436           }
4437         else
4438           {
4439              ELOGF("TZVIS", "Not mapped.. But, iconify by user request", ec);
4440           }
4441      }
4442
4443    TRACE_DS_BEGIN(CLIENT:ICONIFY);
4444
4445    wl_signal_emit_mutable(&PRI(ec)->events.iconify, NULL);
4446    _e_client_hook_call(E_CLIENT_HOOK_ICONIFY, ec);
4447
4448    TRACE_DS_END();
4449 }
4450
4451 E_API void
4452 e_client_uniconify(E_Client *ec)
4453 {
4454    E_Comp_Wl_Client_Data *cdata;
4455
4456    E_OBJECT_CHECK(ec);
4457    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4458
4459    cdata = e_client_cdata_get(ec);
4460
4461    ELOGF("TZVIS", "UNICONIFY|iconic:%d  |argb:%d       |not_raise:%d  |by_client:%d, type:%d |mapped:%d",
4462          ec, ec->iconic, ec->argb, (unsigned int)ec->exp_iconify.not_raise,
4463          ec->exp_iconify.by_client, ec->exp_iconify.type,
4464          cdata ? cdata->mapped : 0);
4465
4466    if (!ec->iconic) return;
4467
4468    TRACE_DS_BEGIN(CLIENT:UNICONIFY);
4469
4470     // call the uniconify hook of a client
4471    wl_signal_emit_mutable(&PRI(ec)->events.uniconify, NULL);
4472    _e_client_hook_call(E_CLIENT_HOOK_UNICONIFY, ec);
4473
4474    TRACE_DS_END();
4475 }
4476
4477 E_API void
4478 e_client_iconified_type_set(E_Client *ec, E_Iconified_Type type)
4479 {
4480    if (!ec) return;
4481    ec->exp_iconify.type = type;
4482 }
4483
4484 EINTERN E_Iconified_Type
4485 e_client_iconified_type_get(E_Client *ec)
4486 {
4487    if (!ec) return E_ICONIFIED_TYPE_NONE;
4488    return ec->exp_iconify.type;
4489 }
4490
4491 E_API Eina_Bool e_client_is_iconified_by_client(E_Client *ec)
4492 {
4493    if (!ec) return EINA_FALSE;
4494
4495    if (ec->exp_iconify.type == E_ICONIFIED_TYPE_ICONIFY_BY_CLIENT)
4496      return EINA_TRUE;
4497
4498    if (ec->exp_iconify.type == E_ICONIFIED_TYPE_DESK_ICONIFY_BY_CLIENT)
4499      return EINA_TRUE;
4500
4501    if (ec->exp_iconify.type == E_ICONIFIED_TYPE_PARENT_ICONIFY_BY_CLIENT)
4502      return EINA_TRUE;
4503
4504    if (ec->exp_iconify.by_client)
4505      {
4506         ELOGF("POL", "CHECK. mismatch value. by_client:%d, type:%d", ec, ec->exp_iconify.by_client, ec->exp_iconify.type);
4507         return EINA_TRUE;
4508      }
4509
4510    return EINA_FALSE;
4511 }
4512
4513 ///////////////////////////////////////
4514
4515 EINTERN void e_client_hide_by_request_set(E_Client *ec, Eina_Bool set)
4516 {
4517    API_ENTRY;
4518    priv->hide_by_request = set;
4519 }
4520
4521 EINTERN Eina_Bool e_client_hide_by_request_get(E_Client *ec)
4522 {
4523    API_ENTRY_VAL(EINA_FALSE);
4524    return priv->hide_by_request;
4525 }
4526
4527 ///////////////////////////////////////
4528
4529 EINTERN void
4530 e_client_stick(E_Client *ec)
4531 {
4532    E_OBJECT_CHECK(ec);
4533    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4534    if (ec->sticky) return;
4535
4536    // call the stick hook of a client
4537    wl_signal_emit_mutable(&PRI(ec)->events.stick, NULL);
4538
4539    // send the sticky property event of a client
4540    _e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
4541 }
4542
4543 EINTERN void
4544 e_client_unstick(E_Client *ec)
4545 {
4546    E_OBJECT_CHECK(ec);
4547    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4548
4549    if (!ec->sticky) return;
4550
4551    // call the unstick hook of a client
4552    wl_signal_emit_mutable(&PRI(ec)->events.unstick, NULL);
4553
4554   // send the sticky property event of a client
4555    _e_client_event_property(ec, E_CLIENT_PROPERTY_STICKY);
4556 }
4557
4558 EINTERN void
4559 e_client_pinned_set(E_Client *ec, Eina_Bool set)
4560 {
4561    E_Layer layer;
4562
4563    EINA_SAFETY_ON_NULL_RETURN(ec);
4564    if (set)
4565      layer = E_LAYER_CLIENT_ABOVE;
4566    else
4567      layer = E_LAYER_CLIENT_NORMAL;
4568
4569    e_client_layer_set(ec, layer);
4570
4571    EC_CHANGED(ec);
4572 }
4573
4574 ///////////////////////////////////////
4575
4576 EINTERN Eina_Bool
4577 e_client_border_set(E_Client *ec, const char *name)
4578 {
4579    Eina_Stringshare *pborder;
4580
4581    E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
4582    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
4583    if (!e_comp_object_frame_allowed(ec->frame)) return EINA_FALSE;
4584    if (ec->border.changed)
4585      CRI("CALLING WHEN border.changed SET!");
4586
4587    if (!e_util_strcmp(ec->border.name, name)) return EINA_TRUE;
4588    pborder = ec->border.name;
4589    ec->border.name = eina_stringshare_add(name);
4590    if (e_comp_object_frame_theme_set(ec->frame, name))
4591      {
4592         eina_stringshare_del(pborder);
4593         return EINA_TRUE;
4594      }
4595    eina_stringshare_del(ec->border.name);
4596    ec->border.name = pborder;
4597    return EINA_FALSE;
4598 }
4599
4600 ///////////////////////////////////////
4601
4602 EINTERN void
4603 e_client_comp_hidden_set(E_Client *ec, Eina_Bool hidden)
4604 {
4605    E_OBJECT_CHECK(ec);
4606    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4607
4608    hidden = !!hidden;
4609    if (ec->comp_hidden == hidden) return;
4610    ec->comp_hidden = hidden;
4611    evas_object_smart_callback_call(ec->frame, "comp_hidden", NULL);
4612 }
4613
4614 ///////////////////////////////////////
4615
4616 EINTERN void
4617 e_client_act_move_keyboard(E_Client *ec)
4618 {
4619    EINA_SAFETY_ON_NULL_RETURN(ec);
4620
4621    if (!_e_client_move_begin(ec))
4622      return;
4623
4624    _e_client_action_init(ec);
4625    _e_client_action_move_timeout_add();
4626
4627    wl_signal_emit_mutable(&PRI(ec)->events.move_update, NULL);
4628    if (!_e_client_hook_call(E_CLIENT_HOOK_MOVE_UPDATE, ec)) return;
4629    evas_object_freeze_events_set(ec->frame, 1);
4630
4631    if (!action_handler_mouse)
4632      action_handler_mouse = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_client_move_mouse_down, NULL);
4633 }
4634
4635 EINTERN void
4636 e_client_act_resize_keyboard(E_Client *ec)
4637 {
4638    EINA_SAFETY_ON_NULL_RETURN(ec);
4639
4640    ec->resize_mode = E_POINTER_RESIZE_TL;
4641    ec->keyboard_resizing = 1;
4642    if (!e_client_resize_begin(ec))
4643      {
4644         ec->keyboard_resizing = 0;
4645         return;
4646      }
4647
4648    _e_client_action_init(ec);
4649    _e_client_action_resize_timeout_add();
4650    evas_object_freeze_events_set(ec->frame, 1);
4651
4652    if (!action_handler_mouse)
4653      action_handler_mouse = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _e_client_resize_mouse_down, NULL);
4654 }
4655
4656 EINTERN void
4657 e_client_act_move_begin(E_Client *ec, E_Binding_Event_Mouse_Button *ev)
4658 {
4659    E_OBJECT_CHECK(ec);
4660    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4661    if (e_client_util_resizing_get(ec) || (ec->moving)) return;
4662    if (ev)
4663      {
4664         char source[256];
4665
4666         snprintf(source, sizeof(source) - 1, "mouse,down,%i", ev->button);
4667         _e_client_moveinfo_gather(ec, source);
4668      }
4669    if (!_e_client_move_begin(ec))
4670      return;
4671
4672    _e_client_action_init(ec);
4673 }
4674
4675 E_API void
4676 e_client_act_move_end(E_Client *ec, E_Binding_Event_Mouse_Button *ev EINA_UNUSED)
4677 {
4678    E_OBJECT_CHECK(ec);
4679    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4680    if (!ec->moving) return;
4681    _e_client_move_end(ec);
4682    _e_client_action_finish();
4683 }
4684
4685 EINTERN void
4686 e_client_act_resize_begin(E_Client *ec, E_Binding_Event_Mouse_Button *ev, E_Pointer_Mode resize_mode)
4687 {
4688    E_OBJECT_CHECK(ec);
4689    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4690    if (ec->lock_user_size) return;
4691    if (e_client_util_resizing_get(ec) || (ec->moving)) return;
4692    if (ev)
4693      {
4694         char source[256];
4695         snprintf(source, sizeof(source) - 1, "mouse,down,%i", ev->button);
4696         _e_client_moveinfo_gather(ec, source);
4697
4698         if (resize_mode != E_POINTER_RESIZE_NONE)
4699           {
4700              ec->resize_mode = resize_mode;
4701           }
4702         else
4703           {
4704              /* Use canvas.x, canvas.y of event.
4705               * Transformed coordinates has to be considered for accurate resize_mode
4706               * rather than absolute coordinates. */
4707              if ((ev->canvas.x > (ec->x + ec->w / 5)) &&
4708                  (ev->canvas.x < (ec->x + ec->w * 4 / 5)))
4709                {
4710                   if (ev->canvas.y < (ec->y + ec->h / 2)) ec->resize_mode = E_POINTER_RESIZE_T;
4711                   else ec->resize_mode = E_POINTER_RESIZE_B;
4712                }
4713              else if (ev->canvas.x < (ec->x + ec->w / 2))
4714                {
4715                   if ((ev->canvas.y > (ec->y + ec->h / 5)) && (ev->canvas.y < (ec->y + ec->h * 4 / 5))) ec->resize_mode = E_POINTER_RESIZE_L;
4716                   else if (ev->canvas.y < (ec->y + ec->h / 2)) ec->resize_mode = E_POINTER_RESIZE_TL;
4717                   else ec->resize_mode = E_POINTER_RESIZE_BL;
4718                }
4719              else
4720                {
4721                   if ((ev->canvas.y > (ec->y + ec->h / 5)) && (ev->canvas.y < (ec->y + ec->h * 4 / 5))) ec->resize_mode = E_POINTER_RESIZE_R;
4722                   else if (ev->canvas.y < (ec->y + ec->h / 2)) ec->resize_mode = E_POINTER_RESIZE_TR;
4723                   else ec->resize_mode = E_POINTER_RESIZE_BR;
4724                }
4725           }
4726      }
4727    if (!e_client_resize_begin(ec))
4728      return;
4729    _e_client_action_init(ec);
4730 }
4731
4732 EINTERN void
4733 e_client_act_resize_end(E_Client *ec, E_Binding_Event_Mouse_Button *ev EINA_UNUSED)
4734 {
4735    E_OBJECT_CHECK(ec);
4736    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4737    if (e_client_util_resizing_get(ec))
4738      {
4739         _e_client_resize_end(ec);
4740         ec->changes.reset_gravity = 1;
4741         if (!e_object_is_del(E_OBJECT(ec)))
4742           EC_CHANGED(ec);
4743      }
4744    _e_client_action_finish();
4745 }
4746
4747 EINTERN void
4748 e_client_act_menu_begin(E_Client *ec, E_Binding_Event_Mouse_Button *ev, int key)
4749 {
4750    E_OBJECT_CHECK(ec);
4751    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4752 }
4753
4754 EINTERN void
4755 e_client_act_close_begin(E_Client *ec)
4756 {
4757    E_OBJECT_CHECK(ec);
4758    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4759    if (ec->lock_close) return;
4760    if (ec->icccm.delete_request)
4761      {
4762         ec->delete_requested = 1;
4763         evas_object_smart_callback_call(ec->frame, "delete_request", NULL);
4764      }
4765    else if (e_config->kill_if_close_not_possible)
4766      {
4767         e_client_act_kill_begin(ec);
4768      }
4769 }
4770
4771 EINTERN void
4772 e_client_act_kill_begin(E_Client *ec)
4773 {
4774    E_OBJECT_CHECK(ec);
4775    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4776    if (ec->internal) return;
4777    if (ec->lock_close) return;
4778    if ((ec->netwm.pid > 1) && (e_config->kill_process))
4779      {
4780         kill(ec->netwm.pid, SIGINT);
4781         ec->kill_timer = ecore_timer_add(e_config->kill_timer_wait,
4782                                          _e_client_cb_kill_timer, ec);
4783      }
4784    else
4785      evas_object_smart_callback_call(ec->frame, "kill_request", NULL);
4786 }
4787
4788 ////////////////////////////////////////////
4789
4790 EINTERN void
4791 e_client_ping(E_Client *ec)
4792 {
4793    E_OBJECT_CHECK(ec);
4794    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4795
4796    if (!e_config->ping_clients) return;
4797
4798    EINA_SAFETY_ON_TRUE_RETURN(e_object_is_del(E_OBJECT(ec)));
4799
4800    ec->ping_ok = 0;
4801    evas_object_smart_callback_call(ec->frame, "ping", NULL);
4802    ec->ping = ecore_loop_time_get();
4803    if (ec->ping_poller) ecore_poller_del(ec->ping_poller);
4804    ec->ping_poller = ecore_poller_add(ECORE_POLLER_CORE,
4805                                       e_config->ping_clients_interval,
4806                                       _e_client_cb_ping_poller, ec);
4807 }
4808
4809 ////////////////////////////////////////////
4810 E_API void
4811 e_client_cursor_map_apply(E_Client *ec, int rotation, int x, int y)
4812 {
4813    // TODO: remove(deprecate) this e_client_cursor_map_apply.
4814 }
4815
4816 EINTERN void
4817 e_client_move_cancel(void)
4818 {
4819    if (!ecmove) return;
4820    if (ecmove->cur_mouse_action)
4821      {
4822         E_Client *ec;
4823
4824         ec = ecmove;
4825         e_object_ref(E_OBJECT(ec));
4826         if (ec->cur_mouse_action->func.end_mouse)
4827           ec->cur_mouse_action->func.end_mouse(E_OBJECT(ec), "", NULL);
4828         else if (ec->cur_mouse_action->func.end)
4829           ec->cur_mouse_action->func.end(E_OBJECT(ec), "");
4830         e_object_unref(E_OBJECT(ec->cur_mouse_action));
4831         ec->cur_mouse_action = NULL;
4832         e_object_unref(E_OBJECT(ec));
4833      }
4834    else
4835      _e_client_move_end(ecmove);
4836 }
4837
4838 EINTERN void
4839 e_client_resize_cancel(void)
4840 {
4841    if (!ecresize) return;
4842    if (ecresize->cur_mouse_action)
4843      {
4844         E_Client *ec;
4845
4846         ec = ecresize;
4847         e_object_ref(E_OBJECT(ec));
4848         if (ec->cur_mouse_action->func.end_mouse)
4849           ec->cur_mouse_action->func.end_mouse(E_OBJECT(ec), "", NULL);
4850         else if (ec->cur_mouse_action->func.end)
4851           ec->cur_mouse_action->func.end(E_OBJECT(ec), "");
4852         e_object_unref(E_OBJECT(ec->cur_mouse_action));
4853         ec->cur_mouse_action = NULL;
4854         e_object_unref(E_OBJECT(ec));
4855      }
4856    else
4857      _e_client_resize_end(ecresize);
4858 }
4859
4860 EINTERN Eina_Bool
4861 e_client_resize_begin(E_Client *ec)
4862 {
4863    if ((ec->fullscreen) || (ec->lock_user_size))
4864      goto error;
4865    if (!_e_client_action_input_win_new()) goto error;
4866    ecresize = ec;
4867    if (ec->manage_resize.enable_aspect_ratio)
4868      {
4869         ELOGF("RESIZE", "Set resize aspect ratio.. ratio(%dx%d)", ec, ec->w, ec->h);
4870         ec->manage_resize.aw = ec->w;
4871         ec->manage_resize.ah = ec->h - ec->manage_resize.header_h - ec->manage_resize.footer_h;
4872      }
4873
4874    wl_signal_emit_mutable(&PRI(ec)->events.move_begin, NULL);
4875    _e_client_hook_call(E_CLIENT_HOOK_RESIZE_BEGIN, ec);
4876    if (ec->transformed)
4877      _e_client_transform_resize_begin(ec);
4878    if (!e_client_util_resizing_get(ec))
4879      {
4880         if (ecresize == ec) ecresize = NULL;
4881         _e_client_action_input_win_del();
4882         return EINA_FALSE;
4883      }
4884    if (!ec->lock_user_stacking)
4885      {
4886         if (e_config->border_raise_on_mouse_action)
4887           e_client_raise(ec);
4888      }
4889
4890    if (e_comp->hwc)
4891      e_comp_client_override_add(ec);
4892
4893    return EINA_TRUE;
4894 error:
4895    ec->resize_mode = E_POINTER_RESIZE_NONE;
4896    return EINA_FALSE;
4897 }
4898
4899
4900 ////////////////////////////////////////////
4901
4902 EINTERN void
4903 e_client_frame_recalc(E_Client *ec)
4904 {
4905    EINA_SAFETY_ON_NULL_RETURN(ec);
4906    if (!ec->frame) return;
4907    evas_object_smart_callback_call(ec->frame, "frame_recalc", NULL);
4908 }
4909
4910 ////////////////////////////////////////////
4911
4912 EINTERN void
4913 e_client_signal_move_begin(E_Client *ec, const char *sig, const char *src EINA_UNUSED)
4914 {
4915    E_OBJECT_CHECK(ec);
4916    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4917
4918    if (e_client_util_resizing_get(ec) || (ec->moving)) return;
4919    _e_client_moveinfo_gather(ec, sig);
4920    if (!_e_client_move_begin(ec)) return;
4921 }
4922
4923 EINTERN void
4924 e_client_signal_move_end(E_Client *ec, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
4925 {
4926    E_OBJECT_CHECK(ec);
4927    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4928    if (!ec->moving) return;
4929    _e_client_move_end(ec);
4930 }
4931
4932 EINTERN void
4933 e_client_signal_resize_begin(E_Client *ec, const char *dir, const char *sig, const char *src EINA_UNUSED)
4934 {
4935    int resize_mode = E_POINTER_RESIZE_BR;
4936
4937    E_OBJECT_CHECK(ec);
4938    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4939
4940    if (e_client_util_resizing_get(ec) || (ec->moving)) return;
4941    if (!strcmp(dir, "tl"))
4942      {
4943         resize_mode = E_POINTER_RESIZE_TL;
4944      }
4945    else if (!strcmp(dir, "t"))
4946      {
4947         resize_mode = E_POINTER_RESIZE_T;
4948      }
4949    else if (!strcmp(dir, "tr"))
4950      {
4951         resize_mode = E_POINTER_RESIZE_TR;
4952      }
4953    else if (!strcmp(dir, "r"))
4954      {
4955         resize_mode = E_POINTER_RESIZE_R;
4956      }
4957    else if (!strcmp(dir, "br"))
4958      {
4959         resize_mode = E_POINTER_RESIZE_BR;
4960      }
4961    else if (!strcmp(dir, "b"))
4962      {
4963         resize_mode = E_POINTER_RESIZE_B;
4964      }
4965    else if (!strcmp(dir, "bl"))
4966      {
4967         resize_mode = E_POINTER_RESIZE_BL;
4968      }
4969    else if (!strcmp(dir, "l"))
4970      {
4971         resize_mode = E_POINTER_RESIZE_L;
4972      }
4973    ec->resize_mode = resize_mode;
4974    _e_client_moveinfo_gather(ec, sig);
4975    if (!e_client_resize_begin(ec))
4976      return;
4977 }
4978
4979 EINTERN void
4980 e_client_signal_resize_end(E_Client *ec, const char *dir EINA_UNUSED, const char *sig EINA_UNUSED, const char *src EINA_UNUSED)
4981 {
4982    E_OBJECT_CHECK(ec);
4983    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4984    if (!e_client_util_resizing_get(ec)) return;
4985    _e_client_resize_handle(ec);
4986    _e_client_resize_end(ec);
4987    ec->changes.reset_gravity = 1;
4988    EC_CHANGED(ec);
4989 }
4990
4991 ////////////////////////////////////////////
4992
4993 EINTERN void
4994 e_client_resize_limit(E_Client *ec, int *w, int *h)
4995 {
4996    E_OBJECT_CHECK(ec);
4997    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
4998
4999    if (ec->frame)
5000      e_comp_object_frame_wh_unadjust(ec->frame, *w, *h, w, h);
5001    if (*h < 1) *h = 1;
5002    if (*w < 1) *w = 1;
5003
5004    if ((ec->icccm.max_w > 0) && (*w > ec->icccm.max_w)) *w = ec->icccm.max_w;
5005    else if (*w < ec->icccm.min_w)
5006      *w = ec->icccm.min_w;
5007    if ((ec->icccm.max_h > 0) && (*h > ec->icccm.max_h)) *h = ec->icccm.max_h;
5008    else if (*h < ec->icccm.min_h)
5009      *h = ec->icccm.min_h;
5010
5011    if (ec->frame)
5012      e_comp_object_frame_wh_adjust(ec->frame, *w, *h, w, h);
5013 }
5014
5015 ////////////////////////////////////////////
5016
5017
5018
5019 EINTERN E_Client *
5020 e_client_under_pointer_get(E_Desk *desk, E_Client *exclude)
5021 {
5022    int x, y;
5023
5024    /* We need to ensure that we can get the comp window for the
5025     * zone of either the given desk or the desk of the excluded
5026     * window, so return if neither is given */
5027    if (desk)
5028      e_input_device_pointer_xy_get(NULL, &x, &y);
5029    else if (exclude)
5030      e_input_device_pointer_xy_get(NULL, &x, &y);
5031    else
5032      return NULL;
5033
5034    if (!desk)
5035      {
5036         desk = exclude->desk;
5037         if (!desk)
5038           {
5039              if (exclude->zone)
5040                desk = e_desk_current_get(exclude->zone);
5041              else
5042                desk = e_desk_current_get(e_zone_current_get());
5043           }
5044      }
5045
5046    return desk ? _e_client_under_pointer_helper(desk, exclude, x, y) : NULL;
5047 }
5048
5049 E_API E_Client *e_client_under_position_get(E_Desk *desk, int x, int y, E_Client *exclude)
5050 {
5051    if (!desk) return NULL;
5052
5053    return _e_client_under_pointer_helper(desk, exclude, x, y);
5054 }
5055
5056 E_API E_Client *e_client_under_position_input_get(E_Desk *desk, int x, int y)
5057 {
5058    if (!desk) return NULL;
5059
5060    return _e_client_under_pointer_input_helper(desk, x, y);
5061 }
5062
5063 ////////////////////////////////////////////
5064
5065 ////////////////////////////////////////////
5066
5067 E_API void
5068 e_client_redirected_set(E_Client *ec, Eina_Bool set)
5069 {
5070    EINA_SAFETY_ON_NULL_RETURN(ec);
5071    if (ec->input_only) return;
5072    set = !!set;
5073    if (ec->redirected == set) return;
5074    if (set)
5075      {
5076         e_client_frame_recalc(ec);
5077
5078         wl_signal_emit_mutable(&PRI(ec)->events.redirect, NULL);
5079         if (!_e_client_hook_call(E_CLIENT_HOOK_REDIRECT, ec)) return;
5080      }
5081    else
5082      {
5083         wl_signal_emit_mutable(&PRI(ec)->events.unredirect, NULL);
5084         if (!_e_client_hook_call(E_CLIENT_HOOK_UNREDIRECT, ec)) return;
5085      }
5086    e_comp_object_redirected_set(ec->frame, set);
5087    ec->redirected = !!set;
5088 }
5089
5090 ////////////////////////////////////////////
5091
5092 E_API void
5093 e_client_transform_update(E_Client *ec)
5094 {
5095    if (e_client_util_resizing_get(ec))
5096      _e_client_transform_resize(ec);
5097 }
5098
5099 ////////////////////////////////////////////
5100
5101 EINTERN void
5102 e_client_transform_apply(E_Client *ec, double angle, double zoom, int cx, int cy)
5103 {
5104    E_Map *map;
5105    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
5106    E_Client *subc;
5107    Eina_List *l;
5108
5109    if (e_comp_wl_subsurface_check(ec))
5110      return;
5111
5112    /* check if it's different with current state */
5113    if ((ec->transform.angle == angle) &&
5114        (ec->transform.zoom == zoom) &&
5115        (ec->transform.center.x == cx) &&
5116        (ec->transform.center.y == cy))
5117      return;
5118
5119    /* use previous value if any required value is invalid */
5120    if (angle == -1.0)
5121      angle = ec->transform.angle;
5122    if (zoom == -1.0)
5123      zoom = ec->transform.zoom;
5124    if (!E_INSIDE(cx, cy,
5125                  ec->client.x, ec->client.y,
5126                  ec->client.w, ec->client.h))
5127      {
5128         cx = ec->transform.center.x;
5129         cy = ec->transform.center.y;
5130      }
5131
5132    if ((angle == 0) && (zoom == 1.0))
5133      {
5134         e_client_transform_clear(ec);
5135         return;
5136      }
5137
5138    map = e_map_new_with_direct_render(ec->transform_core.direct_render);
5139    e_map_util_points_populate_from_object_full(map, ec->frame, 0);
5140
5141    e_map_util_rotate(map, angle, cx, cy);
5142    _e_client_transform_geometry_save(ec, map);
5143
5144    e_map_util_zoom(map, zoom, zoom, cx, cy);
5145
5146    e_map_util_object_move_sync_set(map, EINA_TRUE);
5147    e_client_map_set(ec, map);
5148    e_client_map_enable_set(ec, EINA_TRUE);
5149
5150    EINA_LIST_FOREACH(cdata->sub.list, l, subc)
5151      _e_client_transform_sub_apply(subc, ec, zoom);
5152    EINA_LIST_REVERSE_FOREACH(cdata->sub.below_list, l, subc)
5153      _e_client_transform_sub_apply(subc, ec, zoom);
5154
5155    e_map_free(map);
5156
5157    ec->transform.zoom = zoom;
5158    ec->transform.angle = angle;
5159    ec->transform.center.x = cx;
5160    ec->transform.center.y = cy;
5161    ec->transformed = EINA_TRUE;
5162 }
5163
5164 ////////////////////////////////////////////
5165
5166 EINTERN void
5167 e_client_transform_clear(E_Client *ec)
5168 {
5169    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
5170    E_Client *subc;
5171    Eina_List *l;
5172
5173    e_client_map_enable_set(ec, EINA_FALSE);
5174    e_client_map_set(ec, NULL);
5175
5176    EINA_LIST_FOREACH(cdata->sub.list, l, subc)
5177      _e_client_transform_sub_apply(subc, ec, 1.0);
5178    EINA_LIST_REVERSE_FOREACH(cdata->sub.below_list, l, subc)
5179      _e_client_transform_sub_apply(subc, ec, 1.0);
5180
5181    ec->transform.zoom = 1.0;
5182    ec->transform.angle = 0.0;
5183    ec->transformed = EINA_FALSE;
5184 }
5185
5186 E_API Eina_Bool
5187 e_client_transform_core_enable_get(E_Client *ec)
5188 {
5189    if (!ec) return EINA_FALSE;
5190    return ec->transform_core.result.enable;
5191 }
5192
5193 E_API void
5194 e_client_transform_core_add(E_Client *ec, E_Util_Transform *transform)
5195 {
5196    if (!ec) return;
5197    if (!transform) return;
5198
5199    // duplication check
5200    if (ec->transform_core.transform_list &&
5201        eina_list_data_find(ec->transform_core.transform_list, transform) == transform)
5202      {
5203         return;
5204      }
5205
5206    ec->transform_core.transform_list = eina_list_append(ec->transform_core.transform_list, transform);
5207    ec->transform_core.changed = EINA_TRUE;
5208    e_util_transform_ref(transform);
5209   // e_client_transform_core_update(ec);
5210 }
5211
5212 E_API void
5213 e_client_transform_core_remove(E_Client *ec, E_Util_Transform *transform)
5214 {
5215    if (!ec) return;
5216    if (!transform) return;
5217
5218    if (ec->transform_core.transform_list &&
5219        eina_list_data_find(ec->transform_core.transform_list, transform) == transform)
5220      {
5221         ec->transform_core.transform_list = eina_list_remove(ec->transform_core.transform_list, transform);
5222         e_util_transform_unref(transform);
5223         ec->transform_core.changed = EINA_TRUE;
5224      }
5225
5226    e_client_transform_core_update(ec);
5227 }
5228
5229 E_API void
5230 e_client_transform_core_update(E_Client *ec)
5231 {
5232    if (!ec) return;
5233    if (ec->new_client) return;
5234    if (!_e_client_transform_core_check_change(ec)) return;
5235
5236    if (ec->transform_core.transform_list || ec->transform_core.parent.enable)
5237      {
5238         E_Util_Transform_Rect source_rect;
5239         E_Util_Transform_Matrix matrix, boundary_matrix;
5240         E_Util_Transform_Zoom zoom;
5241         Eina_List *l;
5242         Eina_Bool background;
5243         E_Util_Transform *temp_trans;
5244
5245         // 1. init state
5246         ec->transform_core.result.enable = EINA_TRUE;
5247         e_util_transform_rect_client_rect_get(&source_rect, ec);
5248         e_util_transform_init(&ec->transform_core.result.transform);
5249
5250         // 2. merge transform
5251         EINA_LIST_FOREACH(ec->transform_core.transform_list, l, temp_trans)
5252           {
5253              e_util_transform_merge(&ec->transform_core.result.transform, temp_trans);
5254           }
5255         zoom = ec->transform_core.result.transform.zoom;
5256
5257         // 2.5 check viewport
5258         if (e_util_transform_viewport_flag_get(&ec->transform_core.result.transform))
5259           {
5260              int vx = 0, vy = 0, vw = 0, vh = 0;
5261              e_util_transform_viewport_get(&ec->transform_core.result.transform, &vx, &vy, &vw, &vh);
5262              e_util_transform_rect_init(&source_rect, vx, vy, vw, vh);
5263           }
5264
5265         // 3. apply background transform
5266         matrix = e_util_transform_convert_to_matrix(&ec->transform_core.result.transform, &source_rect);
5267
5268         if (e_util_transform_bg_transform_flag_get(&ec->transform_core.result.transform))
5269           {
5270              boundary_matrix = e_util_transform_bg_convert_to_matrix(&ec->transform_core.result.transform, &source_rect);
5271              background = EINA_TRUE;
5272           }
5273         else
5274           {
5275              background = EINA_FALSE;
5276              boundary_matrix = matrix;
5277           }
5278
5279         if (background != ec->transform_core.background)
5280           {
5281              if (background)
5282                {
5283                   e_comp_object_transform_bg_set(ec->frame, EINA_TRUE);
5284                }
5285              else
5286                {
5287                   e_comp_object_transform_bg_set(ec->frame, EINA_FALSE);
5288                }
5289
5290              ec->transform_core.background = background;
5291           }
5292
5293         // 3.1 if 24bit window then set transp rect
5294         if (!ec->argb)
5295           {
5296              int angle = 0;
5297
5298              e_util_transform_rotation_round_get(&ec->transform_core.result.transform, 0, 0, &angle);
5299              angle %= 90;
5300
5301              if (angle == 0) // when transform angle is 0, 90, 180, 270, 360. then set transp rect
5302                e_comp_object_transform_transp_set(ec->frame, EINA_TRUE);
5303              else
5304                e_comp_object_transform_transp_set(ec->frame, EINA_FALSE);
5305           }
5306         else
5307           e_comp_object_transform_transp_set(ec->frame, EINA_FALSE);
5308
5309         // 3.5 parent matrix multiply
5310         if (ec->transform_core.parent.enable)
5311           {
5312              matrix = e_util_transform_matrix_multiply(&ec->transform_core.parent.matrix,
5313                                                        &matrix);
5314              boundary_matrix = e_util_transform_matrix_multiply(&ec->transform_core.parent.matrix,
5315                                                                 &boundary_matrix);
5316
5317              ec->transform_core.result.transform.use_zoom = EINA_TRUE;
5318              zoom.zoom_x *= ec->transform_core.parent.zoom.zoom_x;
5319              zoom.zoom_y *= ec->transform_core.parent.zoom.zoom_y;
5320              zoom.cx += ec->transform_core.parent.zoom.cx;
5321              zoom.cy += ec->transform_core.parent.zoom.cy;
5322           }
5323
5324         // 4. apply matrix to vertices
5325         ec->transform_core.result.matrix = matrix;
5326         ec->transform_core.result.inv_matrix = e_util_transform_matrix_inverse_get(&matrix);
5327         ec->transform_core.result.vertices = e_util_transform_rect_to_vertices(&source_rect);
5328         ec->transform_core.result.boundary.vertices = e_util_transform_rect_to_vertices(&source_rect);
5329         ec->transform_core.result.vertices = e_util_transform_matrix_multiply_rect_vertex(&matrix,
5330                                                                                           &ec->transform_core.result.vertices);
5331         ec->transform_core.result.boundary.vertices = e_util_transform_matrix_multiply_rect_vertex(&boundary_matrix,
5332                                                                                                    &ec->transform_core.result.boundary.vertices);
5333         ec->transform_core.result.transform.zoom = zoom;
5334
5335         // 5. apply vertices
5336         if (ec->transform_core.result.transform.use_zoom)
5337           {
5338              // TODO: apply zoom values to vertices
5339              e_comp_object_transform_transp_vertices_set_with_zoom(ec->frame, &ec->transform_core.result.vertices,
5340                                                                    ec->transform_core.result.transform.zoom);
5341              e_comp_object_transform_bg_vertices_set_with_zoom(ec->frame, &ec->transform_core.result.boundary.vertices,
5342                                                                ec->transform_core.result.transform.zoom);
5343              _e_client_transform_core_boundary_update(ec, &ec->transform_core.result.boundary.vertices);
5344              _e_client_transform_core_vertices_apply_with_zoom(ec, ec->frame, &ec->transform_core.result.vertices, &ec->transform_core.result.transform,
5345                                                                ec->transform_core.result.transform.zoom);
5346           }
5347         else
5348           {
5349              e_comp_object_transform_transp_vertices_set(ec->frame, &ec->transform_core.result.vertices);
5350              e_comp_object_transform_bg_vertices_set(ec->frame, &ec->transform_core.result.boundary.vertices);
5351              _e_client_transform_core_boundary_update(ec, &ec->transform_core.result.boundary.vertices);
5352              _e_client_transform_core_vertices_apply(ec, ec->frame, &ec->transform_core.result.vertices, &ec->transform_core.result.transform);
5353           }
5354
5355         // 6. subsurface update
5356         _e_client_transform_core_sub_update(ec, &ec->transform_core.result.vertices);
5357
5358         if (!e_object_is_del(E_OBJECT(ec)))
5359           {
5360              wl_signal_emit_mutable(&PRI(ec)->events.transform_change, NULL);
5361              _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
5362           }
5363      }
5364    else
5365      {
5366         if (ec->transform_core.result.enable)
5367           {
5368              ec->transform_core.result.enable = EINA_FALSE;
5369              _e_client_transform_core_vertices_apply(ec, ec->frame, NULL, NULL);
5370              e_comp_object_transform_bg_set(ec->frame, EINA_FALSE);
5371              ec->transform_core.background = EINA_FALSE;
5372              e_comp_object_transform_transp_set(ec->frame, EINA_FALSE);
5373              _e_client_transform_core_sub_update(ec, NULL);
5374
5375              if (!e_object_is_del(E_OBJECT(ec)))
5376                {
5377                   wl_signal_emit_mutable(&PRI(ec)->events.transform_change, NULL);
5378                   _e_client_hook_call(E_CLIENT_HOOK_TRANSFORM_CHANGE, ec);
5379                }
5380           }
5381      }
5382
5383    e_comp_visibility_calculation_set(EINA_TRUE);
5384 }
5385
5386 E_API int
5387 e_client_transform_core_transform_count_get(E_Client *ec)
5388 {
5389    if (!ec) return 0;
5390    if (!ec->transform_core.transform_list) return 0;
5391    return eina_list_count(ec->transform_core.transform_list);
5392 }
5393
5394 E_API E_Util_Transform*
5395 e_client_transform_core_transform_get(E_Client *ec, int index)
5396 {
5397    if (!ec) return NULL;
5398    if (!ec->transform_core.transform_list) return NULL;
5399    if (index < 0 || index >= e_client_transform_core_transform_count_get(ec))
5400       return NULL;
5401
5402    return (E_Util_Transform*)eina_list_nth(ec->transform_core.transform_list, index);
5403 }
5404
5405 E_API void
5406 e_client_transform_core_input_transform(E_Client *ec, int x, int y, int *out_x, int *out_y)
5407 {
5408    E_Util_Transform_Vertex vertex, result_vertex;
5409
5410    if (!ec) return;
5411    if (!e_client_transform_core_enable_get(ec)) return;
5412
5413    e_util_transform_vertex_init(&vertex, x, y, 0.0, 1.0);
5414
5415    result_vertex = e_util_transform_matrix_multiply_vertex(&ec->transform_core.result.inv_matrix, &vertex);
5416    e_util_transform_vertex_pos_round_get(&result_vertex, out_x, out_y, NULL, NULL);
5417 }
5418
5419 E_API void
5420 e_client_transform_core_input_inv_transform(E_Client *ec, int x, int y, int *out_x, int *out_y)
5421 {
5422    E_Util_Transform_Vertex vertex, result_vertex;
5423
5424    if (!ec) return;
5425    if (!e_client_transform_core_enable_get(ec)) return;
5426
5427    e_util_transform_vertex_init(&vertex, x, y, 0.0, 1.0);
5428
5429    result_vertex = e_util_transform_matrix_multiply_vertex(&ec->transform_core.result.matrix, &vertex);
5430    e_util_transform_vertex_pos_round_get(&result_vertex, out_x, out_y, NULL, NULL);
5431 }
5432
5433 EINTERN void
5434 e_client_transform_core_input_inv_rect_transform(E_Client *ec, int x, int y, int *out_x, int *out_y)
5435 {
5436    int gw = 0, gh = 0;
5437    if (!ec) return;
5438    if (!e_client_transform_core_enable_get(ec)) return;
5439    e_client_geometry_get(ec, NULL, NULL, &gw, &gh);
5440
5441    e_util_transform_matrix_inv_rect_coords_get(&ec->transform_core.result.transform,
5442                                                &ec->transform_core.result.vertices,
5443                                                gw, gh,
5444                                                x, y, out_x, out_y);
5445 }
5446
5447 E_API void
5448 e_client_transform_core_direct_render_set(E_Client *ec, Eina_Bool set)
5449 {
5450    EINA_SAFETY_ON_NULL_RETURN(ec);
5451
5452    if (ec->transform_core.direct_render == set) return;
5453
5454    ec->transform_core.direct_render = set;
5455    ec->transform_core.changed = EINA_TRUE;
5456
5457    e_client_transform_core_update(ec);
5458 }
5459
5460 EINTERN E_Pixmap *
5461 e_client_pixmap_change(E_Client *ec, E_Pixmap *newcp)
5462 {
5463    E_Pixmap_Type oldtype, newtype;
5464    E_Pixmap *oldcp;
5465
5466    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
5467    EINA_SAFETY_ON_NULL_RETURN_VAL(ec->pixmap, NULL);
5468    EINA_SAFETY_ON_NULL_RETURN_VAL(newcp, NULL);
5469
5470    oldcp = ec->pixmap;
5471
5472    oldtype = e_pixmap_type_get(oldcp);
5473    if (oldtype >= E_PIXMAP_TYPE_MAX) return NULL;
5474
5475    newtype = e_pixmap_type_get(newcp);
5476    if (newtype >= E_PIXMAP_TYPE_MAX) return NULL;
5477
5478    if (eina_hash_find(clients_hash[oldtype], &oldcp))
5479      eina_hash_del_by_key(clients_hash[oldtype], &oldcp);
5480    e_pixmap_client_set(oldcp, NULL);
5481
5482    ec->pixmap = newcp;
5483    e_pixmap_client_set(newcp, ec);
5484
5485    eina_hash_add(clients_hash[newtype], &newcp, ec);
5486
5487    return oldcp;
5488 }
5489
5490 E_API void
5491 e_client_window_role_set(E_Client *ec, const char *role)
5492 {
5493    EINA_SAFETY_ON_NULL_RETURN(ec);
5494
5495    if (eina_stringshare_replace(&ec->icccm.window_role, role))
5496      {
5497         wl_signal_emit_mutable(&PRI(ec)->events.window_role_change, NULL);
5498         _e_client_hook_call(E_CLIENT_HOOK_WINDOW_ROLE_CHANGE, ec);
5499      }
5500 }
5501
5502 EINTERN Eina_Bool
5503 e_client_key_send(E_Client *ec, int keycode, Eina_Bool pressed, Ecore_Device *dev, unsigned int time)
5504 {
5505    Eina_Bool res;
5506
5507    res = e_comp_wl_key_send(ec, keycode, pressed, dev, time);
5508
5509    return res;
5510 }
5511
5512 EINTERN Eina_Bool
5513 e_client_key_cancel(E_Client *ec, int keycode, Ecore_Device *dev, unsigned int time)
5514 {
5515    Eina_Bool res;
5516
5517    res = e_comp_wl_key_cancel(ec, keycode, dev, time);
5518
5519    return res;
5520 }
5521
5522 EINTERN Eina_Bool
5523 e_client_touch_send(E_Client *ec, int idx, int x, int y, Eina_Bool pressed, Ecore_Device *dev, double radius_x, double radius_y, double pressure, double angle, unsigned int time)
5524 {
5525    Eina_Bool res;
5526
5527    res = e_comp_wl_touch_send(ec, idx, x, y, pressed, dev, radius_x, radius_y, pressure, angle, time);
5528
5529    return res;
5530 }
5531
5532 EINTERN Eina_Bool
5533 e_client_touch_update_send(E_Client *ec, int idx, int x, int y, Ecore_Device *dev, double radius_x, double radius_y, double pressure, double angle, unsigned int time)
5534 {
5535    Eina_Bool res;
5536
5537    res = e_comp_wl_touch_update_send(ec, idx, x, y, dev, radius_x, radius_y, pressure, angle, time);
5538
5539    return res;
5540 }
5541
5542 EINTERN Eina_Bool
5543 e_client_touch_cancel_send(E_Client *ec)
5544 {
5545    Eina_Bool res;
5546
5547    res = e_comp_wl_touch_cancel_send(ec);
5548
5549    return res;
5550 }
5551
5552 EINTERN Eina_Bool
5553 e_client_mouse_button_send(E_Client *ec, int buttons, Eina_Bool pressed, Ecore_Device *dev, unsigned int time)
5554 {
5555    Eina_Bool res;
5556
5557    res = e_comp_wl_mouse_button_send(ec, buttons, pressed, dev, time);
5558
5559    return res;
5560 }
5561
5562 EINTERN Eina_Bool
5563 e_client_mouse_move_send(E_Client *ec, int x, int y, Ecore_Device *dev, unsigned int time)
5564 {
5565    Eina_Bool res;
5566
5567    res = e_comp_wl_mouse_move_send(ec, x, y, dev, time);
5568
5569    return res;
5570 }
5571
5572 EINTERN Eina_Bool
5573 e_client_mouse_wheel_send(E_Client *ec, int direction, int z, Ecore_Device *dev, unsigned int time)
5574 {
5575    Eina_Bool res;
5576
5577    res = e_comp_wl_mouse_wheel_send(ec, direction, z, dev, time);
5578
5579    return res;
5580 }
5581
5582 EINTERN Eina_Bool
5583 e_client_mouse_in_send(E_Client *ec, int x, int y, Ecore_Device *dev, unsigned int time)
5584 {
5585    Eina_Bool res;
5586
5587    res = e_comp_wl_mouse_in_send(ec, x, y, dev, time);
5588
5589    return res;
5590 }
5591
5592 EINTERN Eina_Bool
5593 e_client_mouse_out_send(E_Client *ec, Ecore_Device *dev, unsigned int time)
5594 {
5595    Eina_Bool res;
5596
5597    res = e_comp_wl_mouse_out_send(ec, dev, time);
5598
5599    return res;
5600 }
5601
5602 E_API Eina_Bool
5603 e_client_video_client_has(E_Client *ec)
5604 {
5605    return e_comp_wl_video_subsurface_has(ec);
5606 }
5607
5608 E_API Eina_Bool
5609 e_client_normal_client_has(E_Client *ec)
5610 {
5611    return e_comp_wl_normal_subsurface_has(ec);
5612 }
5613
5614 E_API Eina_Bool
5615 e_client_cursor_hide(E_Client *ec)
5616 {
5617    return e_comp_wl_cursor_hide(ec);
5618 }
5619
5620 E_API void
5621 e_client_visibility_force_obscured_set(E_Client *ec, Eina_Bool set)
5622 {
5623    if (!ec) return;
5624
5625    ELOGF("TZVIS", "VIS_FORCE_OBSCURED :%d", ec, set);
5626
5627    ec->visibility.force_obscured = set;
5628    e_comp_visibility_calculation_set(EINA_TRUE);
5629 }
5630
5631 EINTERN E_Capture_Save_State
5632 e_client_image_save(E_Client *ec, const char *dir, const char *name, E_Capture_Client_Save_End_Cb func_end, void *data, Eina_Bool skip_child)
5633 {
5634    return e_comp_wl_capture_client_image_save(ec, dir, name, func_end, data, skip_child);
5635 }
5636
5637 static void
5638 _e_client_base_output_resolution_hook_subsurf_create(void *data, E_Client *subc)
5639 {
5640    E_Client *ec, *parent;
5641
5642    ec = data;
5643    if (ec != subc)
5644      return;
5645
5646    ec->base_output_resolution.use = 0;
5647    ec->base_output_resolution.w = 0;
5648    ec->base_output_resolution.h = 0;
5649    if (ec->base_output_resolution.transform)
5650      {
5651         e_client_transform_core_remove(ec, ec->base_output_resolution.transform);
5652         E_FREE_FUNC(ec->base_output_resolution.transform, e_util_transform_del);
5653         ELOGF("POL_APPINFO", "Cancel TRANSFORM for subsurface", ec);
5654      }
5655
5656    /* Update transform for toplevel surface.
5657     * The transform of subsurface will be updated by its parent accordingly. */
5658    parent = e_comp_wl_topmost_parent_get(ec);
5659    if (parent)
5660      {
5661         parent->transform_core.changed = EINA_TRUE;
5662         e_client_transform_core_update(parent);
5663      }
5664
5665    /* TODO: Do we need to apply it again if subsurface is destroyed? */
5666 }
5667
5668 static void
5669 _e_client_base_output_resolution_set(E_Client *ec, int width, int height)
5670 {
5671    if (!ec) return;
5672    ec->base_output_resolution.use = 1;
5673    ec->base_output_resolution.w = width;
5674    ec->base_output_resolution.h = height;
5675    ec->base_output_resolution.transform = e_util_transform_new();
5676    e_util_transform_role_set(ec->base_output_resolution.transform, "base_output_resolution");
5677    e_client_transform_core_add(ec, ec->base_output_resolution.transform);
5678
5679    if (!ec->base_output_resolution.hook_subsurf_create)
5680      {
5681         ec->base_output_resolution.hook_subsurf_create =
5682            e_comp_wl_hook_add(E_COMP_WL_HOOK_SUBSURFACE_CREATE,
5683                               _e_client_base_output_resolution_hook_subsurf_create,
5684                               ec);
5685      }
5686 }
5687
5688 E_API void
5689 e_client_base_output_resolution_transform_adjust(E_Client *ec)
5690 {
5691    E_Desk *desk;
5692
5693    EINA_SAFETY_ON_NULL_RETURN(ec);
5694    if (!ec->base_output_resolution.use) return;
5695    if (!ec->base_output_resolution.transform) return;
5696
5697    desk = e_comp_desk_find_by_ec(ec);
5698    EINA_SAFETY_ON_NULL_RETURN(desk);
5699
5700    ELOGF("POL_APPINFO", "Apply TRANSFORM... desk:(%dx%d), ec:(%dx%d)",
5701          ec, desk->geom.w, desk->geom.h, ec->w, ec->h);
5702
5703    e_util_transform_scale(ec->base_output_resolution.transform,
5704                           (double)desk->geom.w /(double)ec->base_output_resolution.w,
5705                           (double)desk->geom.h /(double)ec->base_output_resolution.h,
5706                           1.0);
5707    e_client_transform_core_update(ec);
5708 }
5709
5710 E_API Eina_Bool
5711 e_client_base_output_resolution_update(E_Client *ec)
5712 {
5713    E_Appinfo *eai = NULL;
5714    int configured_width, configured_height;
5715    int width, height;
5716    E_Desk *desk;
5717
5718    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
5719
5720   if (!e_config->configured_output_resolution.use) return EINA_TRUE;
5721   if (ec->base_output_resolution.use) return EINA_TRUE;
5722
5723   /* Check whether it's subsurface or not
5724    * The resolution of subsurface will follow the resolution of its toplevel surface.
5725    * Transform for subsurface will be applied when toplevel surface does by
5726    * implementation of e_client_transform_core.
5727    */
5728   if (e_comp_wl_subsurface_check(ec))
5729     return EINA_FALSE;
5730
5731    desk = e_comp_desk_find_by_ec(ec);
5732    EINA_SAFETY_ON_NULL_RETURN_VAL(desk, EINA_FALSE);
5733
5734   configured_width = e_config->configured_output_resolution.w;
5735   configured_height = e_config->configured_output_resolution.h;
5736
5737   if (!ec->netwm.pid)
5738     {
5739        ELOGF("POL_APPINFO", "NO PID... USE configured_output_resolution(%d,%d) pid:%d", ec,
5740              configured_width, configured_height, ec->netwm.pid);
5741        goto use_configured;
5742     }
5743
5744    eai = e_appinfo_find_with_pid(ec->netwm.pid);
5745    if (!eai)
5746      {
5747         ELOGF("POL_APPINFO", "NO APPINFO... USE configured_output_resolution(%d,%d) pid:%d", ec,
5748               configured_width, configured_height, ec->netwm.pid);
5749         goto use_configured;
5750      }
5751
5752    if (!e_appinfo_base_output_resolution_available_get(eai))
5753      {
5754         ELOGF("POL_APPINFO", "NO AVAILABLE BASE SCREEN RESOLUTION... QUERY base_output_resolution", ec);
5755         e_policy_base_output_resolution_info_update(ec->netwm.pid);
5756      }
5757
5758    if (!e_appinfo_base_output_resolution_get(eai, &width, &height))
5759      {
5760         ELOGF("POL_APPINFO", "NO BASE SCREEN RESOLUTION... USE configured_output_resolution(%d,%d) pid:%d", ec,
5761               configured_width, configured_height, ec->netwm.pid);
5762         goto use_configured;
5763       }
5764
5765    if ((width == 0) && (height == 0))
5766      {
5767         ELOGF("POL_APPINFO", "SKIP SET BASE SCREEN RESOLUTION... base_output_resolution size:(%d,%d) pid:%d", ec, width, height, ec->netwm.pid);
5768         return EINA_TRUE;
5769      }
5770
5771    if ((desk->geom.w == width) && (desk->geom.h == height))
5772      {
5773         ELOGF("POL_APPINFO", "SKIP SET BASE SCREEN RESOLUTION... base_output_resolution is same with desk size:(%d,%d), pid:%d", ec, width, height, ec->netwm.pid);
5774         return EINA_TRUE;
5775      }
5776
5777    /* set the base_output_resolution of the e_client */
5778    _e_client_base_output_resolution_set(ec, width, height);
5779
5780    ELOGF("POL_APPINFO", "USE base_output_resolution(%d,%d) pid:%d", ec, width, height, ec->netwm.pid);
5781
5782    return EINA_TRUE;
5783
5784 use_configured:
5785
5786    if ((desk->geom.w == configured_width) && (desk->geom.h == configured_height))
5787      {
5788         ELOGF("POL_APPINFO", "SKIP use configured_output_resolution (same with desk size:(%d,%d), pid:%d)", ec, configured_width, configured_height, ec->netwm.pid);
5789      }
5790    else
5791      {
5792         /* set the base_output_resolution of the e_client as a default */
5793         _e_client_base_output_resolution_set(ec, configured_width, configured_height);
5794      }
5795
5796    return EINA_TRUE;
5797 }
5798
5799 E_API Eina_Bool
5800 e_client_base_output_resolution_useful_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
5801 {
5802    int zx, zy, zw, zh;
5803    E_Zone *zone;
5804
5805    E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
5806
5807    zone = e_comp_zone_find_by_ec(ec);
5808    EINA_SAFETY_ON_NULL_RETURN_VAL(zone, EINA_FALSE);
5809
5810    e_zone_useful_geometry_get(zone, &zx, &zy, &zw, &zh);
5811
5812    if (x) *x = zx;
5813    if (y) *y = zy;
5814    if (w) *w = zw;
5815    if (h) *h = zh;
5816
5817    if (ec->base_output_resolution.use)
5818      {
5819         if (w) *w = ec->base_output_resolution.w;
5820         if (h) *h = ec->base_output_resolution.h;
5821      }
5822
5823    return EINA_TRUE;
5824 }
5825
5826 E_API Eina_Bool
5827 e_client_base_output_resolution_desk_useful_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h, Eina_Bool consider_obstacle_area)
5828 {
5829    int zx, zy, zw, zh;
5830    E_Zone *zone;
5831
5832    E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
5833
5834    zone = e_comp_zone_find_by_ec(ec);
5835    EINA_SAFETY_ON_NULL_RETURN_VAL(zone, EINA_FALSE);
5836
5837    e_zone_desk_useful_geometry_get(zone, ec->desk, &zx, &zy, &zw, &zh, consider_obstacle_area);
5838
5839    if (x) *x = zx;
5840    if (y) *y = zy;
5841    if (w) *w = zw;
5842    if (h) *h = zh;
5843
5844    if (ec->base_output_resolution.use)
5845      {
5846         // TODO: Consider obstacle area
5847         if (w) *w = ec->base_output_resolution.w;
5848         if (h) *h = ec->base_output_resolution.h;
5849      }
5850
5851    return EINA_TRUE;
5852 }
5853
5854 /* change the base_output_resolution of the bind_ec by checking the base_output_resolution of provider_ec's appinfo */
5855 EINTERN Eina_Bool
5856 e_client_base_output_resolution_rsm_update(E_Client *bind_ec, E_Client *provider_ec)
5857 {
5858    E_Appinfo *epai = NULL;
5859    int configured_width, configured_height;
5860    int width, height;
5861    E_Desk *bind_ec_desk;
5862
5863    EINA_SAFETY_ON_NULL_RETURN_VAL(bind_ec, EINA_FALSE);
5864    EINA_SAFETY_ON_NULL_RETURN_VAL(provider_ec, EINA_FALSE);
5865
5866    bind_ec_desk = e_comp_desk_find_by_ec(bind_ec);
5867    EINA_SAFETY_ON_NULL_RETURN_VAL(bind_ec_desk, EINA_FALSE);
5868
5869   if (!e_config->configured_output_resolution.use) return EINA_TRUE;
5870
5871   configured_width = e_config->configured_output_resolution.w;
5872   configured_height = e_config->configured_output_resolution.h;
5873
5874   if (bind_ec->base_output_resolution.use)
5875     {
5876        ELOGF("POL_APPINFO", "DELETE EXISTED BINDER BASE SCREEN RESOLUTION... base_output_resolution is same with desk size:(%d,%d), bind_pid:%d", bind_ec,
5877              bind_ec->base_output_resolution.w, bind_ec->base_output_resolution.h, bind_ec->netwm.pid);
5878
5879        bind_ec->base_output_resolution.use = 0;
5880        bind_ec->base_output_resolution.w = 0;
5881        bind_ec->base_output_resolution.h = 0;
5882        e_client_transform_core_remove(bind_ec, bind_ec->base_output_resolution.transform);
5883        E_FREE_FUNC(bind_ec->base_output_resolution.transform, e_util_transform_del);
5884     }
5885
5886   if (!provider_ec->netwm.pid)
5887     {
5888        ELOGF("POL_APPINFO", "NO PROVIDER PID... USE configured_output_resolution(%d,%d) provider_pid:%d", provider_ec,
5889              configured_width, configured_height, provider_ec->netwm.pid);
5890        goto use_configured;
5891     }
5892
5893    epai = e_appinfo_find_with_pid(provider_ec->netwm.pid);
5894    if (!epai)
5895      {
5896         ELOGF("POL_APPINFO", "NO PROVIDER APPINFO... USE configured_output_resolution(%d,%d) provider_pid:%d", provider_ec,
5897               configured_width, configured_height, provider_ec->netwm.pid);
5898         goto use_configured;
5899      }
5900
5901    if (!e_appinfo_base_output_resolution_get(epai, &width, &height))
5902      {
5903         ELOGF("POL_APPINFO", "NO PROVIDER APPINFO BASE SCREEN RESOLUTION... USE configured_output_resolution(%d,%d) provider_pid:%d", provider_ec,
5904               configured_width, configured_height, provider_ec->netwm.pid);
5905         goto use_configured;
5906       }
5907
5908    if ((width == 0) && (height == 0))
5909      {
5910         ELOGF("POL_APPINFO", "NO PROVIDER WIDTH and HEIGHT... SKIP base_output_resolution due to size:(%d,%d) provider_pid:%d", provider_ec,
5911              width, height, provider_ec->netwm.pid);
5912         return EINA_TRUE;
5913      }
5914
5915    if ((bind_ec_desk->geom.w == width) && (bind_ec_desk->geom.h == height))
5916      {
5917         ELOGF("POL_APPINFO", "SKIP SET BINDER BASE SCREEN RESOLUTION... base_output_resolution is same with desk size:(%d,%d), bind_pid:%d", bind_ec,
5918             width, height, bind_ec->netwm.pid);
5919         return EINA_TRUE;
5920      }
5921
5922    /* set the base_output_resolution of the e_client */
5923    _e_client_base_output_resolution_set(bind_ec, width, height);
5924    e_client_base_output_resolution_transform_adjust(bind_ec);
5925
5926    ELOGF("POL_APPINFO", "USE BINDER base_output_resolution(%d,%d) bind_pid:%d", bind_ec, width, height, bind_ec->netwm.pid);
5927
5928    return EINA_TRUE;
5929
5930 use_configured:
5931
5932    if ((bind_ec_desk->geom.w == configured_width) && (bind_ec_desk->geom.h == configured_height))
5933      {
5934         ELOGF("POL_APPINFO", "SKIP BINDER use configured_output_resolution (same with desk size:(%d,%d), bind_pid:%d)", bind_ec,
5935              configured_width, configured_height, bind_ec->netwm.pid);
5936      }
5937    else
5938      {
5939         /* set the base_output_resolution of the e_client as a default */
5940         _e_client_base_output_resolution_set(bind_ec, configured_width, configured_height);
5941      }
5942
5943    return EINA_TRUE;
5944 }
5945
5946 /* tizen_move_resize */
5947 EINTERN Eina_Bool
5948 e_client_pending_geometry_has(E_Client *ec)
5949 {
5950    if (!eina_list_count(ec->surface_sync.pending_geometry))
5951      return EINA_FALSE;
5952
5953    return ec->surface_sync.wait_commit;
5954 }
5955
5956 EINTERN void
5957 e_client_pending_geometry_flush(E_Client *ec)
5958 {
5959    E_Client_Pending_Geometry *geo;
5960
5961    if (!eina_list_count(ec->surface_sync.pending_geometry))
5962      {
5963         EINA_LIST_FREE(ec->surface_sync.pending_geometry, geo)
5964           {
5965              E_FREE(geo);
5966           }
5967         ec->surface_sync.wait_commit = EINA_FALSE;
5968         ELOGF("POSSIZE", "pending geometry has flushed", ec);
5969      }
5970 }
5971
5972 EINTERN void
5973 e_client_pending_geometry_last_geometry_get(E_Client *ec, int *x, int *y, int *w, int *h)
5974 {
5975    Eina_List *l;
5976    E_Client_Pending_Geometry *geo;
5977    int gx = 0;
5978    int gy = 0;
5979    int gw = 0;
5980    int gh = 0;
5981
5982    EINA_LIST_REVERSE_FOREACH(ec->surface_sync.pending_geometry, l, geo)
5983      {
5984         gx = geo->x;
5985         gy = geo->y;
5986         gw = geo->w;
5987         gh = geo->h;
5988         break;
5989      }
5990
5991    if (x) *x = gx;
5992    if (y) *y = gy;
5993    if (w) *w = gw;
5994    if (h) *h = gh;
5995 }
5996
5997 E_API void
5998 e_client_frame_focus_set(E_Client *ec, Eina_Bool focus)
5999 {
6000    if (!ec) return;
6001    evas_object_focus_set(ec->frame, focus);
6002 }
6003
6004 EINTERN void
6005 e_client_frame_geometry_set(E_Client *ec, int x, int y, int w, int h)
6006 {
6007    if (!ec) return;
6008
6009    if (ec->internal || ec->input_only)
6010      {
6011         evas_object_geometry_set(ec->frame, x, y, w, h);
6012      }
6013    else
6014      {
6015         if ((ec->w != w) || (ec->h != h))
6016           {
6017              ELOGF("POSSIZE", "Set move_after_resize. old(%d,%d,%dx%d), new(%d,%d,%dx%d)", ec, ec->x, ec->y, ec->w, ec->h, x, y, w, h);
6018              ec->move_after_resize = EINA_TRUE;
6019
6020              e_client_pos_set(ec, x, y);
6021              evas_object_resize(ec->frame, w, h);
6022           }
6023         else
6024           evas_object_geometry_set(ec->frame, x, y, w, h);
6025      }
6026 }
6027
6028 EAPI void
6029 e_client_util_move_resize_without_frame(E_Client *ec, int x, int y, int w, int h)
6030 {
6031    if (!ec) return;
6032
6033    if (ec->internal || ec->input_only)
6034      {
6035         e_client_util_move_without_frame(ec, x, y);
6036         e_client_util_resize_without_frame(ec, w, h);
6037      }
6038    else
6039      {
6040         if ((ec->w != w) || (ec->h != h))
6041           {
6042              ELOGF("POSSIZE", "Set move_after_resize. old(%d,%d,%dx%d), new(%d,%d,%dx%d)", ec, ec->x, ec->y, ec->w, ec->h, x, y, w, h);
6043              ec->move_after_resize = EINA_TRUE;
6044
6045              e_comp_object_frame_xy_adjust(ec->frame, x, y, &x, &y);
6046              e_client_pos_set(ec, x, y);
6047              e_client_util_resize_without_frame(ec, w, h);
6048           }
6049         else
6050           {
6051              e_client_util_move_without_frame(ec, x, y);
6052              e_client_util_resize_without_frame(ec, w, h);
6053           }
6054      }
6055 }
6056
6057 E_API Eina_Bool
6058 e_client_layer_set(E_Client *ec,
6059                    E_Layer layer)
6060 {
6061    E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
6062    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
6063    if (!ec->frame) return EINA_FALSE;
6064
6065    if (e_comp_canvas_client_layer_map(layer) == 9999)
6066      return EINA_FALSE; //invalid layer is not allowed
6067
6068 #ifdef REFACTOR_DESK_AREA
6069 #else
6070    if (ec->desk_area.enable)
6071      {
6072         if (e_client_layer_set_by_desk_area(ec, layer))
6073           {
6074              // restack according to desk group rule
6075              e_desk_area_ec_rearrange(ec->desk_area.desk_area, ec);
6076              return EINA_TRUE;
6077           }
6078      }
6079    ec->desk_area.layer_backup = layer;
6080 #endif
6081
6082    evas_object_layer_set(ec->frame, layer);
6083    if (ec->layer != layer)
6084      {
6085         /* check exceptional case */
6086         if ((ec->fullscreen) &&
6087             (ec->saved.layer != layer))
6088           {
6089              ELOGF("LAYER", "(%d) fail to backup at saved.layer for fullscreen", ec, layer);
6090              return EINA_FALSE;
6091           }
6092         // if e_comp_object fail to change ec->layer due to ec->layer_pending or block
6093         // leave log and apply ec->layer according to set
6094         // as a result it restores back to given layer when pending or block is free
6095         ELOGF("LAYER", "change layer from %d to %d if in case layer pending(%d) or block(%d)",
6096               ec, ec->layer, layer, ec->layer_pending, ec->layer_block);
6097         if (ec->layer_pending || ec->layer_block)
6098           {
6099              ec->layer = layer;
6100              return EINA_TRUE;
6101           }
6102      }
6103
6104    wl_signal_emit_mutable(&PRI(ec)->events.set_layer, NULL);
6105
6106    return EINA_TRUE;
6107 }
6108
6109 E_API E_Layer
6110 e_client_layer_get(E_Client *ec)
6111 {
6112    short layer;
6113
6114    E_OBJECT_CHECK_RETURN(ec, E_LAYER_BOTTOM);
6115    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, E_LAYER_BOTTOM);
6116    if (!ec->frame) return E_LAYER_BOTTOM;
6117
6118    layer = evas_object_layer_get(ec->frame);
6119    if (ec->layer != layer)
6120      {
6121         /* client could be on temperory layer while pending or block,
6122          * in that case, client restores back to ec->layer after pending/block finish */
6123         if (ec->layer_block || ec->layer_pending)
6124           return ec->layer;
6125
6126         /* otherwise, client is on unexpected layer */
6127         ELOGF("LAYER", "layer dismatch ec->layer %d | evas obj layer %d ",
6128               ec, ec->layer, layer);
6129
6130         if (e_comp_canvas_client_layer_map(layer) == 9999)
6131           return E_LAYER_BOTTOM; //not on E_LAYER_CLIENT
6132      }
6133
6134    return ec->layer;
6135 }
6136
6137 #ifdef REFACTOR_DESK_AREA
6138 #else
6139 static void
6140 _e_client_desk_area_original_layer_save(E_Client *ec, E_Layer layer)
6141 {
6142    E_OBJECT_CHECK(ec);
6143    E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
6144    ec->desk_area.layer_backup = layer;
6145 }
6146
6147 EINTERN Eina_Bool
6148 e_client_layer_set_by_desk_area(E_Client *ec, E_Layer layer)
6149 {
6150    E_Desk_Area *eda;
6151    E_Layer edg_layer;
6152    E_Layer org_layer;
6153
6154    if (!ec) return EINA_FALSE;
6155    if (!ec->frame) return EINA_FALSE;
6156    if (!ec->desk_area.enable) return EINA_FALSE;
6157    if (!ec->desk_area.desk_area) return EINA_FALSE;
6158
6159    eda = ec->desk_area.desk_area;
6160
6161    // save original layer
6162    _e_client_desk_area_original_layer_save(ec, layer);
6163
6164    // get desk_area layer
6165    edg_layer = (E_Layer)e_desk_area_layer_get(eda);
6166    org_layer = e_client_desk_area_original_layer_get(ec);
6167
6168    ELOGF("EDG", "layer_set by desk_area... layer:%d, org_layer:%d, new_layer:%d", ec, layer, org_layer, edg_layer);
6169    if (org_layer == edg_layer)
6170      {
6171         e_client_raise(ec);
6172      }
6173    else
6174      {
6175         evas_object_layer_set(ec->frame, edg_layer);
6176         if (edg_layer == ec->layer)
6177           e_client_raise(ec);
6178      }
6179
6180    return EINA_TRUE;
6181 }
6182
6183 EINTERN void
6184 e_client_desk_area_original_layer_restore(E_Client *ec)
6185 {
6186    if (!ec) return;
6187
6188    // Do we need to check ec->desk_area.enable?
6189    // if ec->desk_area.enable is true, then e_client_layer_set calls
6190    // e_desk_area_ec_edg_layer_set(). that's too bad. :(
6191    // so, we MUST make a policy for ordering of the desk group layer restore
6192    // and the desk group enable.
6193    if (ec->desk_area.enable) return;
6194    e_client_layer_set(ec, ec->desk_area.layer_backup);
6195 }
6196
6197 EINTERN E_Layer
6198 e_client_desk_area_original_layer_get(E_Client *ec)
6199 {
6200    if (!ec) return E_LAYER_DESKTOP;
6201
6202    if (ec->desk_area.enable)
6203      return ec->desk_area.layer_backup;
6204    else
6205      return ec->layer;
6206 }
6207
6208 EINTERN Eina_Bool
6209 e_client_desk_area_client_layer_set(E_Client *ec, E_Desk_Area_Client_Layer edgc_layer)
6210 {
6211    E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
6212    E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
6213    if ((edgc_layer < E_DESK_AREA_CLIENT_LAYER_DESKTOP) ||
6214        (edgc_layer >= E_DESK_AREA_CLIENT_LAYER_MAX))
6215      return EINA_FALSE;
6216
6217    ec->desk_area.edgc_layer = edgc_layer;
6218    return EINA_TRUE;
6219 }
6220
6221 EINTERN E_Desk_Area_Client_Layer
6222 e_client_desk_area_client_layer_get(E_Client *ec)
6223 {
6224    E_OBJECT_CHECK_RETURN(ec, E_DESK_AREA_CLIENT_LAYER_DESKTOP);
6225
6226    return ec->desk_area.edgc_layer;
6227 }
6228
6229 //FIXME: use e_desk_area_ec_reassign(eda, ec) instead of this api
6230 E_API Eina_Bool
6231 e_client_desk_area_set(E_Client *ec, E_Desk_Area *eda)
6232 {
6233    E_Desk_Area *old_edg;
6234
6235    if (!ec) return EINA_FALSE;
6236
6237 #if 0 // if this is removed.. then below if (eda != old_edg) is removed also...
6238    if (ec->desk_area.desk_area == eda)
6239      return EINA_TRUE;
6240 #endif
6241
6242    ELOGF("EDG", "Desk Group Set (new:%p, old:%p)", ec, eda, ec->desk_area.desk_area);
6243    old_edg = ec->desk_area.desk_area;
6244    if (old_edg)
6245      e_desk_area_ec_remove(old_edg, ec);
6246
6247    ec->desk_area.desk_area = eda;
6248    e_desk_area_ec_add(eda, ec);
6249
6250 #if 0 // if this is removed.. then above if (ec->desk_area.desk_area == eda) is removed also...
6251    if (eda != old_edg)
6252 #endif
6253      {
6254         e_desk_area_ec_update(eda, ec);
6255         e_desk_area_ec_rearrange(ec->desk_area.desk_area, ec);
6256      }
6257
6258    return EINA_TRUE;
6259 }
6260 #endif
6261
6262 static void
6263 _raise_between_sibling_under_parent(E_Client *ec)
6264 {
6265    ELOGF("POL", "RAISE child window between sibling. So, stack below under the parent (win:%zx, ec:%p)", ec, e_client_util_win_get(ec->parent), ec->parent);
6266    e_client_stack_below(ec, ec->parent);
6267 }
6268
6269 static void
6270 _raise_between_sibling_on_parent(E_Client *ec)
6271 {
6272    E_Client *top_child = NULL;
6273    top_child = e_client_transient_child_top_get(ec->parent, EINA_FALSE);
6274    if (!top_child)
6275      {
6276         ELOGF("POL", "RAISE child window... Stack above on the parent (win:%zx, ec:%p)", ec, e_client_util_win_get(ec->parent), ec->parent);
6277         e_client_stack_above(ec, ec->parent);
6278      }
6279    else
6280      {
6281         if (top_child != ec)
6282           {
6283              ELOGF("POL", "RAISE child window between sibling... Stack above on the top child (win:%zx, ec:%p)", ec, e_client_util_win_get(top_child), top_child);
6284              e_client_stack_above(ec, top_child);
6285           }
6286         else
6287           ELOGF("POL", "RAISE child window between sibling... already on the top. STAY", ec);
6288      }
6289 }
6290
6291 static void
6292 _raise_belong_to_parent(E_Client *ec)
6293 {
6294    if (e_client_transient_policy_get(ec) == E_TRANSIENT_BELOW)
6295      _raise_between_sibling_under_parent(ec);
6296    else
6297      _raise_between_sibling_on_parent(ec);
6298 }
6299
6300 E_API void
6301 e_client_raise(E_Client *ec)
6302 {
6303    if (!ec) return;
6304
6305 #ifdef REFACTOR_DESK_AREA
6306 #else
6307    if (ec->desk_area.enable)
6308      {
6309         E_Desk_Area *eda;
6310         eda = ec->desk_area.desk_area;
6311         if (eda)
6312           {
6313              e_desk_area_ec_raise(eda, ec);
6314              return;
6315           }
6316      }
6317 #endif
6318
6319    if (ec->parent && e_client_is_belong_to_parent(ec))
6320      _raise_belong_to_parent(ec);
6321    else
6322      evas_object_raise(ec->frame);
6323
6324    wl_signal_emit_mutable(&PRI(ec)->events.raise, NULL);
6325 }
6326
6327 static void
6328 _e_client_transient_for_below_group_make(E_Client *ec, Eina_List **list)
6329 {
6330    // list : Head is the bottommost child
6331    E_Client *child;
6332    Eina_List *l;
6333
6334    if (!ec) return;
6335
6336    EINA_LIST_REVERSE_FOREACH(ec->transients, l, child)
6337      {
6338         if (!child) continue;
6339         if (e_client_transient_policy_get(child) != E_TRANSIENT_BELOW) continue;
6340         if (!e_client_is_belong_to_parent(child)) continue;
6341
6342         *list = eina_list_prepend(*list, child);
6343         _e_client_transient_for_group_make(child, list);
6344      }
6345 }
6346
6347 E_API E_Client *
6348 e_client_transient_child_bottom_get(E_Client *ec)
6349 {
6350    E_Client *bottom_ec = NULL;
6351    Eina_List *transient_below_list = NULL;
6352    Eina_List *l = NULL;
6353
6354    _e_client_transient_for_below_group_make(ec, &transient_below_list);
6355
6356    if (transient_below_list)
6357      {
6358         E_Client *temp_ec = NULL;
6359         E_Client *temp_ec2 = NULL;
6360
6361         E_CLIENT_FOREACH(temp_ec)
6362           {
6363              if (bottom_ec) break;
6364
6365              if (temp_ec == ec)
6366                {
6367                   bottom_ec = ec;
6368                   break;
6369                }
6370
6371              EINA_LIST_FOREACH(transient_below_list, l, temp_ec2)
6372                {
6373                   if (temp_ec == temp_ec2)
6374                     {
6375                        bottom_ec = temp_ec2;
6376                        break;
6377                     }
6378                }
6379           }
6380         eina_list_free(transient_below_list);
6381      }
6382    return bottom_ec;
6383 }
6384
6385 static void
6386 _lower_between_sibling_under_parent(E_Client *ec)
6387 {
6388    E_Client *bottom_child = NULL;
6389    bottom_child = e_client_transient_child_bottom_get(ec->parent);
6390    if (!bottom_child)
6391      {
6392         ELOGF("POL", "LOWER child window between sibling... Stack below under the parent (win:%zx, ec:%p)", ec, e_client_util_win_get(ec->parent), ec->parent);
6393         e_client_stack_below(ec, ec->parent);
6394      }
6395    else
6396      {
6397         if (bottom_child != ec)
6398           {
6399              ELOGF("POL", "LOWER child window between sibling... Stack below under the bottom child (win:%zx, ec:%p)", ec, e_client_util_win_get(bottom_child), bottom_child);
6400              e_client_stack_below(ec, bottom_child);
6401           }
6402         else
6403           ELOGF("POL", "LOWER child window between sibling... already under the bottom. STAY", ec);
6404      }
6405 }
6406
6407 static void
6408 _lower_between_sibling_on_parent(E_Client *ec)
6409 {
6410    ELOGF("POL", "LOWER child window between sibling... So, stack above on the parent (win:%zx, ec:%p)", ec, e_client_util_win_get(ec->parent), ec->parent);
6411    e_client_stack_above(ec, ec->parent);
6412 }
6413
6414 static void
6415 _lower_belong_to_parent(E_Client *ec)
6416 {
6417    if (e_client_transient_policy_get(ec) == E_TRANSIENT_BELOW)
6418      _lower_between_sibling_under_parent(ec);
6419    else
6420      _lower_between_sibling_on_parent(ec);
6421 }
6422
6423 E_API void
6424 e_client_lower(E_Client *ec)
6425 {
6426    if (!ec) return;
6427
6428 #ifdef REFACTOR_DESK_AREA
6429 #else
6430    if (ec->desk_area.enable)
6431      {
6432         E_Desk_Area *eda;
6433         eda = ec->desk_area.desk_area;
6434         if (eda)
6435           {
6436              e_desk_area_ec_lower(eda, ec);
6437
6438              wl_signal_emit_mutable(&PRI(ec)->events.lower, NULL);
6439              return;
6440           }
6441      }
6442 #endif
6443
6444    if (ec->parent && e_client_is_belong_to_parent(ec))
6445      _lower_belong_to_parent(ec);
6446    else
6447      evas_object_lower(ec->frame);
6448
6449    wl_signal_emit_mutable(&PRI(ec)->events.lower, NULL);
6450 }
6451
6452 E_API void
6453 e_client_stack_above(E_Client *ec, E_Client *above)
6454 {
6455    if (!ec) return;
6456    if (!ec->frame) return;
6457    if (!above) return;
6458    if (!above->frame) return;
6459
6460 #ifdef REFACTOR_DESK_AREA
6461 #else
6462    if (ec->desk_area.enable)
6463      {
6464         E_Desk_Area *eda;
6465         eda = ec->desk_area.desk_area;
6466         if (eda)
6467           {
6468              e_desk_area_ec_stack_above(eda, ec, above);
6469              return;
6470           }
6471      }
6472 #endif
6473
6474    evas_object_stack_above(ec->frame, above->frame);
6475
6476    wl_signal_emit_mutable(&PRI(ec)->events.stack_above, NULL);
6477 }
6478
6479 E_API void
6480 e_client_stack_below(E_Client *ec, E_Client *below)
6481 {
6482    if (!ec) return;
6483    if (!ec->frame) return;
6484    if (!below) return;
6485    if (!below->frame) return;
6486
6487 #ifdef REFACTOR_DESK_AREA
6488 #else
6489    if (ec->desk_area.enable)
6490      {
6491         E_Desk_Area *eda;
6492         eda = ec->desk_area.desk_area;
6493         if (eda)
6494           {
6495              e_desk_area_ec_stack_below(eda, ec, below);
6496              return;
6497           }
6498      }
6499 #endif
6500
6501    evas_object_stack_below(ec->frame, below->frame);
6502
6503    wl_signal_emit_mutable(&PRI(ec)->events.stack_below, NULL);
6504 }
6505
6506 E_API int
6507 e_client_show_pending_set(E_Client *ec)
6508 {
6509    if (!ec) return 0;
6510
6511    ec->show_pending.count++;
6512    ELOGF("E_CLIENT", "SET show_pending. (count:%d, run:%d)", ec, ec->show_pending.count, ec->show_pending.running);
6513    return ec->show_pending.count;
6514 }
6515
6516 E_API int
6517 e_client_show_pending_unset(E_Client *ec)
6518 {
6519    if (!ec) return 0;
6520    if (ec->show_pending.count <= 0) return 0;
6521
6522    ec->show_pending.count--;
6523    ELOGF("E_CLIENT", "UNSET show_pending. (count:%d, run:%d)", ec, ec->show_pending.count, ec->show_pending.running);
6524    if (ec->show_pending.count == 0 && ec->show_pending.running)
6525      {
6526         ec->show_pending.running = EINA_FALSE;
6527         if (ec->frame)
6528           {
6529              ELOGF("E_CLIENT", "evas_object_show by unset show_pending", ec);
6530              evas_object_show(ec->frame);
6531              //e_comp_object_damage(ec->frame, 0, 0, ec->w, ec->h);
6532              EC_CHANGED(ec);
6533           }
6534      }
6535
6536    return ec->show_pending.count;
6537 }
6538
6539 static Eina_Bool
6540 _e_client_surface_tree_foreach_helper(E_Client *ec, E_Client_Surface_Tree_Foreach func, void *data)
6541 {
6542    E_Client *subc;
6543    Eina_List *l, *ll;
6544    Eina_Bool res = EINA_TRUE;
6545    E_Comp_Wl_Client_Data *cdata = e_client_cdata_get(ec);
6546
6547    if (!cdata)
6548      return res;
6549
6550    EINA_LIST_FOREACH_SAFE(cdata->sub.below_list, l, ll, subc)
6551      {
6552         res = _e_client_surface_tree_foreach_helper(subc, func, data);
6553         if (!res)
6554           break;
6555      }
6556
6557    if (res)
6558      {
6559         res = func(data, ec);
6560         if (res)
6561           {
6562              EINA_LIST_FOREACH_SAFE(cdata->sub.list, l, ll, subc)
6563                {
6564                   res = _e_client_surface_tree_foreach_helper(subc,
6565                                                               func,
6566                                                               data);
6567                   if (!res)
6568                     break;
6569                }
6570           }
6571      }
6572
6573    return res;
6574 }
6575
6576 E_API void
6577 e_client_surface_tree_foreach(E_Client *ec, E_Client_Surface_Tree_Foreach func, void *data)
6578 {
6579    EINA_SAFETY_ON_NULL_RETURN(ec);
6580    EINA_SAFETY_ON_NULL_RETURN(func);
6581
6582    _e_client_surface_tree_foreach_helper(ec, func, data);
6583 }
6584
6585 EINTERN E_Comp_Wl_Client_Data *
6586 e_client_cdata_new(E_Client *ec)
6587 {
6588    E_Comp_Wl_Client_Data *cdata;
6589
6590    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
6591
6592    if (!(cdata = E_NEW(E_Comp_Wl_Client_Data, 1)))
6593      {
6594         ERR("Could not allocate new E_Comp_Wl_Client_Data structure");
6595         return NULL;
6596      }
6597    ec->comp_data = cdata;
6598
6599    return cdata;
6600 }
6601
6602 EINTERN void
6603 e_client_cdata_free(E_Client *ec)
6604 {
6605   EINA_SAFETY_ON_NULL_RETURN(ec);
6606   if (!ec->comp_data) return;
6607
6608   E_FREE(ec->comp_data);
6609 }
6610
6611 EINTERN E_Comp_Wl_Client_Data *
6612 e_client_cdata_get(E_Client *ec)
6613 {
6614    if (!ec) return NULL;
6615
6616    return ec->comp_data;
6617 }
6618
6619 EINTERN Eina_Bool
6620 e_client_map_set(E_Client *ec, E_Map *em)
6621 {
6622    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6623
6624    return e_map_set_to_comp_object(em, ec->frame);
6625 }
6626
6627 E_API E_Map *
6628 e_client_map_get(const E_Client *ec)
6629 {
6630    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, NULL);
6631
6632    return e_map_get_from_comp_object(ec->frame);
6633 }
6634
6635 EINTERN Eina_Bool
6636 e_client_map_enable_set(E_Client *ec, Eina_Bool enable)
6637 {
6638    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6639    EINA_SAFETY_ON_NULL_RETURN_VAL(ec->frame, EINA_FALSE);
6640
6641    evas_object_map_enable_set(ec->frame, enable);
6642
6643    return EINA_TRUE;
6644 }
6645
6646 EINTERN void
6647 e_client_belong_to_parent_set(E_Client *ec, Eina_Bool set)
6648 {
6649    if (!ec) return;
6650    ec->belong_to_parent = set;
6651 }
6652
6653 EINTERN Eina_Bool
6654 e_client_is_belong_to_parent(E_Client *ec)
6655 {
6656    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6657    return ec->belong_to_parent;
6658 }
6659
6660 EINTERN void
6661 e_client_transient_policy_set(E_Client *ec, E_Transient policy)
6662 {
6663    if (!ec) return;
6664    ec->transient_policy = policy;
6665 }
6666
6667 E_API E_Transient
6668 e_client_transient_policy_get(E_Client *ec)
6669 {
6670    if (!ec) return E_TRANSIENT_ABOVE;
6671    return ec->transient_policy;
6672 }
6673
6674 EINTERN void
6675 e_client_resize_object_create_cb_set(E_Client_Resize_Object_Create_Cb cb)
6676 {
6677    if (_e_client_resize_object_create_cb && cb)
6678      CRI("ATTEMPTING TO OVERWRITE EXISTING CLIENT RESIZE OBJECT CREATE HOOK!!!");
6679    _e_client_resize_object_create_cb = cb;
6680 }
6681
6682 EINTERN void
6683 e_client_resize_unit_size_set(E_Client *ec, unsigned int unit_size)
6684 {
6685    if (!ec) return;
6686
6687    // FYI, we consider 0 and 1 to be the same value as a default unit size.
6688    ec->manage_resize.unit_size = unit_size;
6689 }
6690
6691 EINTERN void
6692 e_client_desk_zoom_enable_set(E_Client *ec, Eina_Bool enable)
6693 {
6694    if (!ec) return;
6695    ec->desk_zoom.enable = enable;
6696 }
6697
6698 EINTERN Eina_Bool
6699 e_client_desk_zoom_enable_get(E_Client *ec)
6700 {
6701    if (!ec) return EINA_FALSE;
6702    return ec->desk_zoom.enable;
6703 }
6704
6705 EINTERN void
6706 e_client_layout_apply(E_Client *ec, Eina_Bool apply)
6707 {
6708    if (!ec) return;
6709    ec->apply_layout = apply;
6710 }
6711
6712 EINTERN Eina_Bool
6713 e_client_is_layout_apply(E_Client *ec)
6714 {
6715    if (!ec) return EINA_FALSE;
6716    return ec->apply_layout;
6717 }
6718
6719 E_API E_Client *
6720 e_client_from_surface_resource(struct wl_resource *surface_resource)
6721 {
6722    EINA_SAFETY_ON_NULL_RETURN_VAL(surface_resource, NULL);
6723
6724    return e_comp_wl_util_client_from_surface_resource(surface_resource);
6725 }
6726
6727 EINTERN void
6728 e_client_fps_update(E_Client *ec)
6729 {
6730    double dt;
6731    double tim;
6732
6733    EINA_SAFETY_ON_NULL_RETURN(ec);
6734
6735    if (!ec->fps.enabled) return;
6736
6737    tim = ecore_time_get();
6738
6739    dt = tim - ec->fps.frametimes[0];
6740
6741    ec->fps.frametimes[0] = tim;
6742    ec->fps.time += dt;
6743    ec->fps.cframes++;
6744
6745    if (ec->fps.lapse == 0.0)
6746      {
6747         ec->fps.lapse = tim;
6748         ec->fps.flapse = ec->fps.cframes;
6749      }
6750    else if ((tim - ec->fps.lapse) >= 0.5)
6751      {
6752         ec->fps.fps = (ec->fps.cframes - ec->fps.flapse) /
6753                       (tim - ec->fps.lapse);
6754         ec->fps.lapse = tim;
6755         ec->fps.flapse = ec->fps.cframes;
6756         ec->fps.time = 0.0;
6757      }
6758 }
6759
6760 EINTERN Eina_Bool
6761 e_client_fps_get(E_Client *ec, double *fps)
6762 {
6763    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6764
6765    if (ec->fps.old_fps == ec->fps.fps)
6766      return EINA_FALSE;
6767
6768    if (ec->fps.fps > 0.0)
6769      {
6770         *fps = ec->fps.fps;
6771         ec->fps.old_fps = ec->fps.fps;
6772         return EINA_TRUE;
6773      }
6774
6775    return EINA_FALSE;
6776 }
6777
6778 EINTERN void
6779 e_client_fps_enable(E_Client *ec, Eina_Bool enable)
6780 {
6781    EINA_SAFETY_ON_NULL_RETURN(ec);
6782
6783    ec->fps.enabled = enable;
6784 }
6785
6786 EINTERN Eina_Bool
6787 e_client_explicit_sync_get(E_Client *ec)
6788 {
6789    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6790
6791    return ec->explicit_sync;
6792 }
6793
6794 EINTERN Eina_Bool
6795 e_client_explicit_sync_set(E_Client *ec, Eina_Bool enable)
6796 {
6797    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6798
6799    ec->explicit_sync = enable;
6800
6801    return EINA_TRUE;
6802 }
6803
6804 EINTERN int
6805 e_client_explicit_sync_acquire_fence_fd_get(E_Client *ec)
6806 {
6807    EINA_SAFETY_ON_NULL_RETURN_VAL(ec, -1);
6808
6809    return ec->acquire_fence_fd;
6810 }
6811
6812 EINTERN Eina_Bool
6813 e_client_explicit_sync_acquire_fence_fd_set(E_Client *ec, int fd)
6814 {
6815   EINA_SAFETY_ON_NULL_RETURN_VAL(ec, EINA_FALSE);
6816
6817   ec->acquire_fence_fd = fd;
6818
6819   return EINA_TRUE;
6820 }
6821
6822 EINTERN Eina_Bool
6823 e_client_intercept_hook_auto_placement_call(E_Client *ec)
6824 {
6825   // no need to call the intercept hook if ec is NULL.
6826   if (!ec) return EINA_FALSE;
6827
6828   if (!_e_client_intercept_hook_call(E_CLIENT_INTERCEPT_HOOK_AUTO_PLACEMENT, ec))
6829     {
6830        ELOGF("FOCUS", "E_CLIENT_INTERCEPT_HOOK_AUTO_PLACEMENT Intercepted.", ec);
6831        return EINA_TRUE;
6832     }
6833
6834   return EINA_FALSE;
6835 }
6836
6837 EINTERN void
6838 e_client_iconify_event_send(E_Client *ec)
6839 {
6840    EINA_SAFETY_ON_NULL_RETURN(ec);
6841
6842    _e_client_event_simple(ec, E_EVENT_CLIENT_ICONIFY);
6843 }
6844
6845 EINTERN void
6846 e_client_uniconify_event_send(E_Client *ec)
6847 {
6848    EINA_SAFETY_ON_NULL_RETURN(ec);
6849
6850    _e_client_event_simple(ec, E_EVENT_CLIENT_UNICONIFY);
6851 }
6852
6853 EINTERN void
6854 e_client_stack_transient_for_done_notify(E_Client *ec)
6855 {
6856    EINA_SAFETY_ON_NULL_RETURN(ec);
6857
6858    wl_signal_emit_mutable(&PRI(ec)->events.stack_transient_for_done, NULL);
6859 }
6860
6861 #ifdef REFACTOR_DESK_AREA
6862 EINTERN void
6863 e_client_subsurface_stack_update(E_Client *ec)
6864 {
6865    EINA_SAFETY_ON_NULL_RETURN(ec);
6866
6867    wl_signal_emit_mutable(&PRI(ec)->events.subsurface_stack_update, ec);
6868 }
6869 #endif
6870
6871 EINTERN void
6872 e_client_eval_pre_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
6873 {
6874    API_ENTRY;
6875    wl_signal_add(&priv->events.eval_pre_fetch, listener);
6876 }
6877
6878 EINTERN void
6879 e_client_eval_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
6880 {
6881    API_ENTRY;
6882    wl_signal_add(&priv->events.eval_fetch, listener);
6883 }
6884
6885 EINTERN void
6886 e_client_eval_pre_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
6887 {
6888    API_ENTRY;
6889    wl_signal_add(&priv->events.eval_pre_post_fetch, listener);
6890 }
6891
6892 EINTERN void
6893 e_client_eval_post_fetch_listener_add(E_Client *ec, struct wl_listener *listener)
6894 {
6895    API_ENTRY;
6896    wl_signal_add(&priv->events.eval_post_fetch, listener);
6897 }
6898
6899 EINTERN void
6900 e_client_eval_pre_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
6901 {
6902    API_ENTRY;
6903    wl_signal_add(&priv->events.eval_pre_frame_assign, listener);
6904 }
6905
6906 EINTERN void
6907 e_client_eval_post_frame_assign_listener_add(E_Client *ec, struct wl_listener *listener)
6908 {
6909    API_ENTRY;
6910    wl_signal_add(&priv->events.eval_post_frame_assign, listener);
6911 }
6912
6913 EINTERN void
6914 e_client_eval_pre_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
6915 {
6916    API_ENTRY;
6917    wl_signal_add(&priv->events.eval_pre_new_client, listener);
6918 }
6919
6920 EINTERN void
6921 e_client_eval_post_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
6922 {
6923    API_ENTRY;
6924    wl_signal_add(&priv->events.eval_post_new_client, listener);
6925 }
6926
6927 EINTERN void
6928 e_client_eval_visibility_listener_add(E_Client *ec, struct wl_listener *listener)
6929 {
6930    API_ENTRY;
6931    wl_signal_add(&priv->events.eval_visibility, listener);
6932 }
6933
6934 EINTERN void
6935 e_client_eval_visibility_end_listener_add(E_Client *ec, struct wl_listener *listener)
6936 {
6937    API_ENTRY;
6938    wl_signal_add(&priv->events.eval_visibility_end, listener);
6939 }
6940
6941 EINTERN void
6942 e_client_eval_end_listener_add(E_Client *ec, struct wl_listener *listener)
6943 {
6944    API_ENTRY;
6945    wl_signal_add(&priv->events.eval_end, listener);
6946 }
6947
6948 EINTERN void
6949 e_client_move_begin_listener_add(E_Client *ec, struct wl_listener *listener)
6950 {
6951    API_ENTRY;
6952    wl_signal_add(&priv->events.move_begin, listener);
6953 }
6954
6955 EINTERN void
6956 e_client_move_update_listener_add(E_Client *ec, struct wl_listener *listener)
6957 {
6958    API_ENTRY;
6959    wl_signal_add(&priv->events.move_update, listener);
6960 }
6961
6962 EINTERN void
6963 e_client_move_end_listener_add(E_Client *ec, struct wl_listener *listener)
6964 {
6965    API_ENTRY;
6966    wl_signal_add(&priv->events.move_end, listener);
6967 }
6968
6969 EINTERN void
6970 e_client_move_resize_begin_listener_add(E_Client *ec, struct wl_listener *listener)
6971 {
6972    API_ENTRY;
6973    wl_signal_add(&priv->events.move_resize_begin, listener);
6974 }
6975
6976 EINTERN void
6977 e_client_move_resize_update_listener_add(E_Client *ec, struct wl_listener *listener)
6978 {
6979    API_ENTRY;
6980    wl_signal_add(&priv->events.move_resize_update, listener);
6981 }
6982
6983 EINTERN void
6984 e_client_move_resize_end_listener_add(E_Client *ec, struct wl_listener *listener)
6985 {
6986    API_ENTRY;
6987    wl_signal_add(&priv->events.move_resize_end, listener);
6988 }
6989
6990 EINTERN void
6991 e_client_destroy_listener_add(E_Client *ec, struct wl_listener *listener)
6992 {
6993    API_ENTRY;
6994    wl_signal_add(&priv->events.destroy, listener);
6995 }
6996
6997 EINTERN void
6998 e_client_new_client_listener_add(E_Client *ec, struct wl_listener *listener)
6999 {
7000    API_ENTRY;
7001    wl_signal_add(&priv->events.new_client, listener);
7002 }
7003
7004 EINTERN void
7005 e_client_new_client_post_listener_add(E_Client *ec, struct wl_listener *listener)
7006 {
7007    API_ENTRY;
7008    wl_signal_add(&priv->events.new_client_post, listener);
7009 }
7010
7011 EINTERN void
7012 e_client_unredirect_listener_add(E_Client *ec, struct wl_listener *listener)
7013 {
7014    API_ENTRY;
7015    wl_signal_add(&priv->events.unredirect, listener);
7016 }
7017
7018 EINTERN void
7019 e_client_redirect_listener_add(E_Client *ec, struct wl_listener *listener)
7020 {
7021    API_ENTRY;
7022    wl_signal_add(&priv->events.redirect, listener);
7023 }
7024
7025 EINTERN void
7026 e_client_aux_hint_change_listener_add(E_Client *ec, struct wl_listener *listener)
7027 {
7028    API_ENTRY;
7029    wl_signal_add(&priv->events.aux_hint_change, listener);
7030 }
7031
7032 EINTERN void
7033 e_client_window_role_change_listener_add(E_Client *ec, struct wl_listener *listener)
7034 {
7035    API_ENTRY;
7036    wl_signal_add(&priv->events.window_role_change, listener);
7037 }
7038
7039 EINTERN void
7040 e_client_transform_change_listener_add(E_Client *ec, struct wl_listener *listener)
7041 {
7042    API_ENTRY;
7043    wl_signal_add(&priv->events.transform_change, listener);
7044 }
7045
7046 EINTERN void
7047 e_client_activate_done_listener_add(E_Client *ec, struct wl_listener *listener)
7048 {
7049    API_ENTRY;
7050    wl_signal_add(&priv->events.activate_done, listener);
7051 }
7052
7053 EINTERN void
7054 e_client_mouse_in_listener_add(E_Client *ec, struct wl_listener *listener)
7055 {
7056    API_ENTRY;
7057    wl_signal_add(&priv->events.mouse_in, listener);
7058 }
7059
7060 EINTERN void
7061 e_client_mouse_out_listener_add(E_Client *ec, struct wl_listener *listener)
7062 {
7063    API_ENTRY;
7064    wl_signal_add(&priv->events.mouse_out, listener);
7065 }
7066
7067 EINTERN void
7068 e_client_mouse_down_listener_add(E_Client *ec, struct wl_listener *listener)
7069 {
7070    API_ENTRY;
7071    wl_signal_add(&priv->events.mouse_down, listener);
7072 }
7073
7074 EINTERN void
7075 e_client_focus_set_listener_add(E_Client *ec, struct wl_listener *listener)
7076 {
7077    API_ENTRY;
7078    wl_signal_add(&priv->events.focus_set, listener);
7079 }
7080
7081 EINTERN void
7082 e_client_focus_unset_listener_add(E_Client *ec, struct wl_listener *listener)
7083 {
7084    API_ENTRY;
7085    wl_signal_add(&priv->events.focus_unset, listener);
7086 }
7087
7088 EINTERN void
7089 e_client_focus_defer_set_listener_add(E_Client *ec, struct wl_listener *listener)
7090 {
7091    API_ENTRY;
7092    wl_signal_add(&priv->events.focus_defer_set, listener);
7093 }
7094
7095 EINTERN void
7096 e_client_focus_latest_set_listener_add(E_Client *ec, struct wl_listener *listener)
7097 {
7098    API_ENTRY;
7099    wl_signal_add(&priv->events.focus_latest_set, listener);
7100 }
7101
7102 EINTERN void
7103 e_client_iconify_listener_add(E_Client *ec, struct wl_listener *listener)
7104 {
7105    API_ENTRY;
7106    wl_signal_add(&priv->events.iconify, listener);
7107 }
7108
7109 EINTERN void
7110 e_client_uniconify_listener_add(E_Client *ec, struct wl_listener *listener)
7111 {
7112    API_ENTRY;
7113    wl_signal_add(&priv->events.uniconify, listener);
7114 }
7115
7116 EINTERN void
7117 e_client_maximize_listener_add(E_Client *ec, struct wl_listener *listener)
7118 {
7119    API_ENTRY;
7120    wl_signal_add(&priv->events.maximize, listener);
7121 }
7122
7123 EINTERN void
7124 e_client_unmaximize_listener_add(E_Client *ec, struct wl_listener *listener)
7125 {
7126    API_ENTRY;
7127    wl_signal_add(&priv->events.unmaximize, listener);
7128 }
7129
7130 EINTERN void
7131 e_client_fullscreen_pre_listener_add(E_Client *ec, struct wl_listener *listener)
7132 {
7133    API_ENTRY;
7134    wl_signal_add(&priv->events.fullscreen_pre, listener);
7135 }
7136
7137 EINTERN void
7138 e_client_fullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
7139 {
7140    API_ENTRY;
7141    wl_signal_add(&priv->events.fullscreen, listener);
7142 }
7143
7144 EINTERN void
7145 e_client_unfullscreen_listener_add(E_Client *ec, struct wl_listener *listener)
7146 {
7147    API_ENTRY;
7148    wl_signal_add(&priv->events.unfullscreen, listener);
7149 }
7150
7151 EINTERN void
7152 e_client_move_listener_add(E_Client *ec, struct wl_listener *listener)
7153 {
7154    API_ENTRY;
7155    wl_signal_add(&priv->events.move, listener);
7156 }
7157
7158 EINTERN void
7159 e_client_raise_listener_add(E_Client *ec, struct wl_listener *listener)
7160 {
7161    API_ENTRY;
7162    wl_signal_add(&priv->events.raise, listener);
7163 }
7164
7165 EINTERN void
7166 e_client_lower_listener_add(E_Client *ec, struct wl_listener *listener)
7167 {
7168    API_ENTRY;
7169    wl_signal_add(&priv->events.lower, listener);
7170 }
7171
7172 EINTERN void
7173 e_client_stack_below_listener_add(E_Client *ec, struct wl_listener *listener)
7174 {
7175    API_ENTRY;
7176    wl_signal_add(&priv->events.stack_below, listener);
7177 }
7178
7179 EINTERN void
7180 e_client_stack_above_listener_add(E_Client *ec, struct wl_listener *listener)
7181 {
7182    API_ENTRY;
7183    wl_signal_add(&priv->events.stack_above, listener);
7184 }
7185
7186 EINTERN void
7187 e_client_set_layer_listener_add(E_Client *ec, struct wl_listener *listener)
7188 {
7189    API_ENTRY;
7190    wl_signal_add(&priv->events.set_layer, listener);
7191 }
7192
7193 EINTERN void
7194 e_client_stack_transient_for_done_listener_add(E_Client *ec, struct wl_listener *listener)
7195 {
7196    API_ENTRY;
7197    wl_signal_add(&priv->events.stack_transient_for_done, listener);
7198 }
7199
7200 EINTERN void
7201 e_client_stick_listener_add(E_Client *ec, struct wl_listener *listener)
7202 {
7203    API_ENTRY;
7204    wl_signal_add(&priv->events.stick, listener);
7205 }
7206
7207 EINTERN void
7208 e_client_unstick_listener_add(E_Client *ec, struct wl_listener *listener)
7209 {
7210    API_ENTRY;
7211    wl_signal_add(&priv->events.unstick, listener);
7212 }
7213
7214 EINTERN struct wl_listener *
7215 e_client_destroy_listener_get(E_Client *ec, wl_notify_func_t notify)
7216 {
7217    API_ENTRY_VAL(NULL);
7218    return wl_signal_get(&priv->events.destroy, notify);
7219 }
7220
7221 #ifdef REFACTOR_DESK_AREA
7222 EINTERN void
7223 e_client_get_above_listener_add(E_Client *ec, struct wl_listener *listener)
7224 {
7225    API_ENTRY;
7226    wl_signal_add(&priv->events.get_above, listener);
7227 }
7228
7229 EINTERN void
7230 e_client_get_below_listener_add(E_Client *ec, struct wl_listener *listener)
7231 {
7232    API_ENTRY;
7233    wl_signal_add(&priv->events.get_below, listener);
7234 }
7235
7236 EINTERN void
7237 e_client_get_visible_above_listener_add(E_Client *ec, struct wl_listener *listener)
7238 {
7239    API_ENTRY;
7240    wl_signal_add(&priv->events.get_visible_above, listener);
7241 }
7242
7243 EINTERN void
7244 e_client_get_visible_below_listener_add(E_Client *ec, struct wl_listener *listener)
7245 {
7246    API_ENTRY;
7247    wl_signal_add(&priv->events.get_visible_below, listener);
7248 }
7249
7250 EINTERN void
7251 e_client_subsurface_stack_update_listener_add(E_Client *ec, struct wl_listener *listener)
7252 {
7253    API_ENTRY;
7254    wl_signal_add(&priv->events.subsurface_stack_update, listener);
7255 }
7256 #endif
7257
7258 EINTERN void
7259 e_client_shell_configure_send(E_Client *ec, uint32_t edges, int32_t width, int32_t height)
7260 {
7261    EINA_SAFETY_ON_NULL_RETURN(ec);
7262    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7263
7264    if ((!ec->comp_data->shell.surface) ||
7265        (!ec->comp_data->shell.configure_send))
7266      return;
7267
7268    ec->comp_data->shell.configure_send(ec->comp_data->shell.surface, edges, width, height);
7269 }
7270
7271 EINTERN void
7272 e_client_shell_configure(E_Client *ec, Evas_Coord x, Evas_Coord y, Evas_Coord width, Evas_Coord height)
7273 {
7274    EINA_SAFETY_ON_NULL_RETURN(ec);
7275    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7276
7277    if ((!ec->comp_data->shell.surface) ||
7278        (!ec->comp_data->shell.configure))
7279      return;
7280
7281    ec->comp_data->shell.configure(ec->comp_data->shell.surface, x, y, width, height);
7282 }
7283
7284 EINTERN void
7285 e_client_shell_ping(E_Client *ec)
7286 {
7287    EINA_SAFETY_ON_NULL_RETURN(ec);
7288    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7289
7290    if ((!ec->comp_data->shell.surface) ||
7291        (!ec->comp_data->shell.ping))
7292      return;
7293
7294    ec->comp_data->shell.ping(ec->comp_data->shell.surface);
7295 }
7296
7297 static void
7298 _e_client_shell_map(E_Client *ec)
7299 {
7300    EINA_SAFETY_ON_NULL_RETURN(ec);
7301    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7302
7303    if ((!ec->comp_data->shell.surface) ||
7304        (!ec->comp_data->shell.map))
7305      return;
7306
7307    ec->comp_data->shell.map(ec->comp_data->shell.surface);
7308 }
7309
7310 EINTERN void
7311 e_client_shell_unmap(E_Client *ec)
7312 {
7313    EINA_SAFETY_ON_NULL_RETURN(ec);
7314    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7315
7316    if ((!ec->comp_data->shell.surface) ||
7317        (!ec->comp_data->shell.unmap))
7318      return;
7319
7320    ec->comp_data->shell.unmap(ec->comp_data->shell.surface);
7321 }
7322
7323 EINTERN void
7324 e_client_show(E_Client *ec)
7325 {
7326    EINA_SAFETY_ON_NULL_RETURN(ec);
7327    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7328
7329    if (ec->comp_data->mapped)
7330      return;
7331
7332    if ((ec->comp_data->shell.surface) && (ec->comp_data->shell.map) &&
7333        (!ec->ignored))
7334      {
7335         ELOGF("E_CLIENT", "Map.", ec);
7336         _e_client_shell_map(ec);
7337      }
7338    else if (ec->internal || e_comp_wl_subsurface_can_show(ec) ||
7339             (ec == e_comp_wl->drag_client))
7340      {
7341         ELOGF("E_CLIENT", "Map. internal:%d, drag:%d",
7342               ec, ec->internal, (ec == e_comp_wl->drag_client));
7343         ec->visible = EINA_TRUE;
7344         ec->ignored = 0;
7345         evas_object_show(ec->frame);
7346         ec->comp_data->mapped = 1;
7347      }
7348 }
7349
7350 EINTERN void
7351 e_client_hide(E_Client *ec)
7352 {
7353    API_ENTRY;
7354
7355    EINA_SAFETY_ON_NULL_RETURN(ec->comp_data);
7356
7357    if (!ec->comp_data->mapped)
7358      return;
7359
7360    if ((ec->comp_data->shell.surface) && (ec->comp_data->shell.unmap))
7361      {
7362         ELOGF("E_CLIENT", "Unmap", ec);
7363
7364         if (priv->hide_by_request)
7365           ELOGF("COMP", "Currenlty hide_by_request state.", ec);
7366
7367         if (ec->show_pending.count > 0)
7368           {
7369              ELOGF("E_CLIENT", "Reset show_pending!!! (count:%d, run:%d)", ec, ec->show_pending.count, ec->show_pending.running);
7370              ec->show_pending.count = 0;
7371              if (ec->show_pending.running)
7372                {
7373                   // need to send visibility false;
7374                   ec->visibility.obscured = E_VISIBILITY_UNOBSCURED;
7375                   ELOGF("POL_VIS", "CLIENT VIS ON (fake).  argb:%d, opaque:%2d", ec, ec->argb, ec->visibility.opaque);
7376                   EC_CHANGED(ec);
7377                }
7378              ec->show_pending.running = EINA_FALSE;
7379           }
7380         e_client_shell_unmap(ec);
7381      }
7382    else if ((ec->internal) || (e_comp_wl_subsurface_check(ec)) ||
7383             (ec == e_comp_wl->drag_client))
7384      {
7385         ELOGF("E_CLIENT", "Unmap. internal:%d, sub:%p, drag:%d",
7386               ec, ec->internal, ec->comp_data->sub.data, (ec == e_comp_wl->drag_client));
7387         ec->visible = EINA_FALSE;
7388         evas_object_hide(ec->frame);
7389         ec->comp_data->mapped = 0;
7390      }
7391 }