move-tizen/src/e_mod_move_apptray.c

   1 #include "e_mod_move_shared_types.h"
   2 #include "e_mod_move_debug.h"
   3 #include "e_mod_move_atoms.h"
   4 #include "e_mod_move.h"
   5
   6 struct _E_Move_Apptray_Animation_Data
   7 {
   8    Eina_Bool       animating;
   9    int             sx;// start x
  10    int             sy;// start y
  11    int             ex;// end x
  12    int             ey;// end y
  13    int             dx;// distance x
  14    int             dy;// distance y
  15    Ecore_Animator *animator;
  16 };
  17
  18 /* local subsystem functions */
  19 static Eina_Bool      _e_mod_move_apptray_cb_motion_start(void *data, void *event_info);
  20 static Eina_Bool      _e_mod_move_apptray_cb_motion_move(void *data, void *event_info);
  21 static Eina_Bool      _e_mod_move_apptray_cb_motion_end(void *data, void *event_info);
  22 static Eina_Bool      _e_mod_move_apptray_objs_position_set(E_Move_Border *mb, int x, int y);
  23 static Eina_Bool      _e_mod_move_apptray_objs_position_get(E_Move_Border *mb, int *x, int *y);
  24 static Eina_Bool      _e_mod_move_apptray_objs_animation_frame(void  *data, double pos);
  25 static Eina_Bool      _e_mod_move_apptray_flick_process(E_Move_Border *mb, int angle, Eina_Bool state);
  26 static Eina_Bool      _e_mod_move_apptray_dim_objs_apply(E_Move_Border *mb, int x, int y);
  27 static Eina_Bool      _e_mod_move_apptray_cb_bg_touch_dn(void *data, int type __UNUSED__, void *event);
  28 static Eina_Bool      _e_mod_move_apptray_cb_bg_touch_up(void *data, int type __UNUSED__, void *event);
  29 static void           _e_mod_move_apptray_bg_touch_win_show(E_Move_Border *mb);
  30 static void           _e_mod_move_apptray_bg_touch_win_hide(E_Move_Border *mb);
  31 static Ecore_X_Window _e_mod_move_apptray_bg_touch_win_get(E_Move_Border *mb);
  32
  33 /* local subsystem functions */
  34 static Eina_Bool
  35 _e_mod_move_apptray_cb_motion_start(void *data,
  36                                     void *event_info)
  37 {
  38    E_Move_Border *mb = (E_Move_Border *)data;
  39    E_Move_Event_Motion_Info *info;
  40    E_Move_Control_Object *mco = NULL;
  41    Evas_Event_Mouse_Down *mouse_down_event = NULL;
  42    Eina_Bool clicked = EINA_FALSE;
  43    Eina_List *l;
  44    int angle = 0;
  45
  46    info  = (E_Move_Event_Motion_Info *)event_info;
  47    if (!mb || !info) return EINA_FALSE;
  48
  49    mouse_down_event = info->event_info;
  50    E_CHECK_RETURN(mouse_down_event, EINA_FALSE);
  51    if (mouse_down_event->button != 1)
  52      return EINA_FALSE;
  53
  54    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  55      {
  56         if (!mco) continue;
  57         clicked = e_mod_move_event_click_get(mco->event);
  58      }
  59    if (clicked)
  60      return EINA_FALSE;
  61
  62    L(LT_EVENT_OBJ,
  63      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
  64      "EVAS_OBJ", mb->bd->win, __func__);
  65
  66    if (e_mod_move_apptray_objs_animation_state_get(mb)) goto error_cleanup;
  67
  68    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  69      {
  70         if (!mco) continue;
  71         angle = e_mod_move_event_angle_get(mco->event);
  72      }
  73    mb->angle = angle;
  74
  75    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  76      {
  77         if (!mco) continue;
  78         e_mod_move_event_click_set(mco->event, EINA_TRUE);
  79      }
  80
  81    E_CHECK_GOTO(mb->visible, error_cleanup);
  82    if (!REGION_INSIDE_ZONE(mb, mb->bd->zone))
  83       goto error_cleanup;
  84
  85    E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
  86    e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
  87
  88    e_mod_move_apptray_objs_add(mb);
  89
  90    // apptray_objs_animation_layer_set
  91    e_mod_move_apptray_objs_animation_layer_set(mb);
  92
  93    // send apptray to "move start message".
  94    e_mod_move_apptray_anim_state_send(mb, EINA_TRUE);
  95    return EINA_TRUE;
  96
  97 error_cleanup:
  98    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  99      {
 100         if (!mco) continue;
 101         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 102      }
 103    return EINA_FALSE;
 104 }
 105
 106 static Eina_Bool
 107 _e_mod_move_apptray_cb_motion_move(void *data,
 108                                    void *event_info)
 109 {
 110    E_Move_Border *mb = (E_Move_Border *)data;
 111    E_Move_Event_Motion_Info *info;
 112    E_Move_Control_Object *mco = NULL;
 113    Eina_List *l;
 114    int angle = 0;
 115    Eina_Bool click = EINA_FALSE;
 116    E_Zone *zone = NULL;
 117
 118    info  = (E_Move_Event_Motion_Info *)event_info;
 119    if (!mb || !info) return EINA_FALSE;
 120
 121    SL(LT_EVENT_OBJ,
 122       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 123       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 124       __func__);
 125
 126    angle = mb->angle;
 127    zone = mb->bd->zone;
 128
 129    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 130      {
 131         if (!mco) continue;
 132         click = e_mod_move_event_click_get(mco->event);
 133      }
 134    E_CHECK_RETURN(click, EINA_FALSE);
 135
 136    switch (angle)
 137      {
 138       case   0:
 139          if (info->coord.y < mb->h)
 140            e_mod_move_apptray_objs_move(mb, 0, info->coord.y - mb->h);
 141          break;
 142       case  90:
 143          if (info->coord.x < mb->w)
 144            e_mod_move_apptray_objs_move(mb, info->coord.x - mb->w, 0);
 145          break;
 146       case 180:
 147          if (info->coord.y > (zone->h - mb->h))
 148            e_mod_move_apptray_objs_move(mb, 0, info->coord.y);
 149          break;
 150       case 270:
 151          if (info->coord.x > (zone->w - mb->w))
 152            e_mod_move_apptray_objs_move(mb, info->coord.x, 0);
 153          break;
 154       default :
 155          break;
 156      }
 157
 158    return EINA_TRUE;
 159 }
 160
 161 static Eina_Bool
 162 _e_mod_move_apptray_cb_motion_end(void *data,
 163                                   void *event_info)
 164 {
 165    E_Move_Border *mb = (E_Move_Border *)data;
 166    E_Move_Event_Motion_Info *info;
 167    E_Move_Control_Object *mco = NULL;
 168    Eina_List *l;
 169    int angle = 0;
 170    E_Zone *zone = NULL;
 171    Eina_Bool click = EINA_FALSE;
 172    Eina_Bool flick_state = EINA_FALSE;
 173    Evas_Event_Mouse_Up *mouse_up_event;
 174    int check_w, check_h;
 175
 176    info  = (E_Move_Event_Motion_Info *)event_info;
 177    if (!mb || !info) return EINA_FALSE;
 178
 179    mouse_up_event = info->event_info;
 180    E_CHECK_RETURN(mouse_up_event, EINA_FALSE);
 181    if (mouse_up_event->button != 1)
 182      return EINA_FALSE;
 183
 184    SL(LT_EVENT_OBJ,
 185       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 186       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 187       __func__);
 188
 189    angle = mb->angle;
 190    zone = mb->bd->zone;
 191
 192    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 193      {
 194         if (!mco) continue;
 195         click = e_mod_move_event_click_get(mco->event);
 196      }
 197    E_CHECK_GOTO(click, finish);
 198
 199    e_mod_move_flick_data_update(mb, info->coord.x, info->coord.y);
 200    flick_state = e_mod_move_flick_state_get(mb, EINA_FALSE);
 201    if (_e_mod_move_apptray_flick_process(mb, angle, flick_state))
 202      {
 203         return EINA_TRUE;
 204      }
 205
 206    switch (angle)
 207      {
 208       case   0:
 209          check_h = mb->y + mb->h;
 210          if (check_h) check_h /= 2;
 211          if (info->coord.y < check_h)
 212            {
 213               e_mod_move_apptray_e_border_move(mb, 0, mb->h * -1);
 214               e_mod_move_apptray_objs_animation_move(mb, 0, mb->h * -1);
 215            }
 216          else
 217            {
 218               e_mod_move_apptray_objs_animation_move(mb, 0, 0);
 219            }
 220          break;
 221       case  90:
 222          check_w = mb->w;
 223          if (check_w) check_w /= 2;
 224          if (info->coord.x < check_w)
 225            {
 226               e_mod_move_apptray_e_border_move(mb, mb->w * -1, 0);
 227               e_mod_move_apptray_objs_animation_move(mb, mb->w * -1, 0);
 228            }
 229          else
 230            {
 231               e_mod_move_apptray_objs_animation_move(mb, 0, 0);
 232            }
 233          break;
 234       case 180:
 235          check_h = mb->h;
 236          if (check_h) check_h /= 2;
 237          if (info->coord.y > (zone->h - check_h))
 238            {
 239               e_mod_move_apptray_e_border_move(mb, 0, zone->h);
 240               e_mod_move_apptray_objs_animation_move(mb, 0, zone->h);
 241            }
 242          else
 243            {
 244               e_mod_move_apptray_objs_animation_move(mb, 0, (zone->h - mb->h));
 245            }
 246          break;
 247       case 270:
 248          check_w = mb->w;
 249          if (check_w) check_w /= 2;
 250          if (info->coord.x > (zone->w - check_w))
 251            {
 252               e_mod_move_apptray_e_border_move(mb, zone->w, 0);
 253               e_mod_move_apptray_objs_animation_move(mb, zone->w, 0);
 254            }
 255          else
 256            {
 257               e_mod_move_apptray_objs_animation_move(mb, zone->w - mb->w, 0);
 258            }
 259          break;
 260       default :
 261          break;
 262      }
 263
 264    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 265      {
 266         if (!mco) continue;
 267         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 268      }
 269
 270 finish:
 271    if (mb->flick_data) e_mod_move_flick_data_free(mb);
 272    return EINA_TRUE;
 273 }
 274
 275 static Eina_Bool
 276 _e_mod_move_apptray_objs_position_set(E_Move_Border *mb,
 277                                       int            x,
 278                                       int            y)
 279 {
 280    E_Move_Apptray_Data *at_data = NULL;
 281    at_data = (E_Move_Apptray_Data *)mb->data;
 282    if (!at_data)
 283      at_data = (E_Move_Apptray_Data *)e_mod_move_apptray_internal_data_add(mb);
 284    E_CHECK_RETURN(at_data, EINA_FALSE);
 285
 286    at_data->x = x;
 287    at_data->y = y;
 288    mb->data = at_data;
 289    return EINA_TRUE;
 290 }
 291
 292 static Eina_Bool
 293 _e_mod_move_apptray_objs_position_get(E_Move_Border *mb,
 294                                       int           *x,
 295                                       int           *y)
 296 {
 297    E_Move_Apptray_Data *at_data = NULL;
 298    at_data = (E_Move_Apptray_Data *)mb->data;
 299    E_CHECK_RETURN(at_data, EINA_FALSE);
 300
 301    *x = at_data->x;
 302    *y = at_data->y;
 303
 304    return EINA_TRUE;
 305 }
 306
 307 static Eina_Bool
 308 _e_mod_move_apptray_objs_animation_frame(void  *data,
 309                                          double pos)
 310 {
 311    E_Move_Apptray_Animation_Data *anim_data = NULL;
 312    E_Move_Border                 *mb = NULL;
 313    double                         frame = pos;
 314    int                            x, y;
 315
 316    anim_data = (E_Move_Apptray_Animation_Data *)data;
 317    E_CHECK_RETURN(anim_data, EINA_FALSE);
 318
 319    mb = e_mod_move_apptray_find();
 320    E_CHECK_RETURN(mb, EINA_FALSE);
 321
 322    frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE, 0.0, 0.0);
 323    x = anim_data->sx + anim_data->dx * frame;
 324    y = anim_data->sy + anim_data->dy * frame;
 325
 326    e_mod_move_apptray_objs_move(mb, x, y);
 327
 328    if (pos >= 1.0)
 329      {
 330         // apptray_objs_animation_layer_unset
 331         e_mod_move_apptray_objs_animation_layer_unset(mb);
 332
 333         if (!(REGION_INSIDE_ZONE(mb, mb->bd->zone)))
 334           {
 335              e_border_focus_set(mb->bd, 0, 0);
 336              e_border_lower(mb->bd);
 337              e_mod_move_apptray_dim_hide(mb);
 338           }
 339
 340         // send apptray to "move end message".
 341         SLOG(LOG_DEBUG, "E17_MOVE_MODULE","[e17:X_CLIENT_MESSAGE:Apptray:ANIMATION_END]");
 342         e_mod_move_apptray_anim_state_send(mb, EINA_FALSE);
 343
 344         e_mod_move_apptray_objs_del(mb);
 345
 346         memset(anim_data, 0, sizeof(E_Move_Apptray_Animation_Data));
 347         E_FREE(anim_data);
 348         mb->anim_data = NULL;
 349      }
 350    return EINA_TRUE;
 351 }
 352
 353 static Eina_Bool
 354 _e_mod_move_apptray_flick_process(E_Move_Border *mb,
 355                                   int            angle,
 356                                   Eina_Bool      state)
 357 {
 358    E_Move_Control_Object *mco = NULL;
 359    E_Zone *zone = NULL;
 360    Eina_List *l;
 361    int x, y;
 362
 363    E_CHECK_RETURN(mb, EINA_FALSE);
 364    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 365    E_CHECK_RETURN(state, EINA_FALSE);
 366
 367    zone = mb->bd->zone;
 368
 369    /* apptray click unset */
 370    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 371      {
 372         if (!mco) continue;
 373         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 374      }
 375
 376    e_mod_move_flick_data_free(mb);
 377
 378    switch (angle)
 379      {
 380       case  90: x = mb->w * -1; y = 0;          break;
 381       case 180: x = 0;          y = zone->h;    break;
 382       case 270: x = zone->w;    y = 0;          break;
 383       case   0:
 384       default : x = 0;          y = mb->h * -1; break;
 385      }
 386
 387    e_mod_move_apptray_e_border_move(mb, x, y);
 388    e_mod_move_apptray_objs_animation_move(mb, x, y);
 389
 390    return EINA_TRUE;
 391 }
 392
 393 static Eina_Bool
 394 _e_mod_move_apptray_dim_objs_apply(E_Move_Border *mb,
 395                                    int            x,
 396                                    int            y)
 397 {
 398    int angle;
 399    int mx, my;
 400    int opacity;
 401    E_Zone *zone = NULL;
 402    int dim_max = 255;
 403    E_Move_Apptray_Data *at_data = NULL;
 404
 405    E_CHECK_RETURN(mb, EINA_FALSE);
 406    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 407    E_CHECK_RETURN(mb->data, EINA_FALSE);
 408
 409    at_data = (E_Move_Apptray_Data *)mb->data;
 410    E_CHECK_RETURN(at_data->dim_objs, EINA_FALSE);
 411
 412    angle = mb->angle;
 413    zone = mb->bd->zone;
 414    dim_max = mb->m->dim_max_opacity;
 415
 416    switch (angle)
 417      {
 418       case  90:
 419          mx = x + mb->w;
 420          if (mb->w)
 421            opacity = dim_max * mx / mb->w;
 422          else
 423            opacity = dim_max;
 424          break;
 425       case 180:
 426          my = zone->h - y;
 427          if (mb->h)
 428            opacity = dim_max * my / mb->h;
 429          else
 430            opacity = dim_max;
 431          break;
 432       case 270:
 433          mx = zone->w - x;
 434          if (mb->w)
 435            opacity = dim_max * mx / mb->w;
 436          else
 437            opacity = dim_max;
 438          break;
 439       case   0:
 440       default :
 441          my = y + mb->h;
 442          if (mb->h)
 443            opacity = dim_max * my / mb->h;
 444          else
 445            opacity = dim_max;
 446          break;
 447      }
 448
 449    e_mod_move_bd_move_dim_objs_opacity_set(at_data->dim_objs, opacity);
 450    at_data->opacity = opacity;
 451    return EINA_TRUE;
 452 }
 453
 454 static Eina_Bool
 455 _e_mod_move_apptray_cb_bg_touch_dn(void    *data,
 456                                    int type __UNUSED__,
 457                                    void    *event)
 458 {
 459    Ecore_Event_Mouse_Button *ev = (Ecore_Event_Mouse_Button *)event;
 460    E_Move_Apptray_Data *at_data = (E_Move_Apptray_Data *)data;
 461
 462    E_CHECK_RETURN(at_data, ECORE_CALLBACK_PASS_ON);
 463    E_CHECK_RETURN(ev, ECORE_CALLBACK_PASS_ON);
 464
 465    if (ev->buttons != 1)
 466      return ECORE_CALLBACK_PASS_ON;
 467
 468    if (ev->event_window != at_data->bg_touch.win)
 469      return ECORE_CALLBACK_PASS_ON;
 470
 471    at_data->bg_touch.click = EINA_TRUE;
 472
 473    return ECORE_CALLBACK_PASS_ON;
 474 }
 475
 476 static Eina_Bool
 477 _e_mod_move_apptray_cb_bg_touch_up(void    *data,
 478                                    int type __UNUSED__,
 479                                    void    *event)
 480 {
 481    Ecore_Event_Mouse_Button *ev = (Ecore_Event_Mouse_Button *)event;
 482    E_Move_Apptray_Data      *at_data = (E_Move_Apptray_Data *)data;
 483    Eina_Bool                 state;
 484    E_Move_Border            *at_mb = NULL;
 485    E_Zone                   *zone = NULL;
 486    Ecore_X_Window            at_win;
 487    int                       angles[2];
 488    int                       x, y;
 489    x = 0; y = 0;
 490
 491    E_CHECK_RETURN(at_data, ECORE_CALLBACK_PASS_ON);
 492    E_CHECK_RETURN(ev, ECORE_CALLBACK_PASS_ON);
 493
 494    if (ev->buttons != 1)
 495      return ECORE_CALLBACK_PASS_ON;
 496
 497    if (ev->event_window != at_data->bg_touch.win)
 498      return ECORE_CALLBACK_PASS_ON;
 499
 500    E_CHECK_RETURN(at_data->bg_touch.click, ECORE_CALLBACK_PASS_ON);
 501
 502    at_mb = e_mod_move_apptray_find();
 503    E_CHECK_RETURN(at_mb, ECORE_CALLBACK_PASS_ON);
 504
 505    at_win = e_mod_move_util_client_xid_get(at_mb);
 506    if (e_mod_move_util_win_prop_angle_get(at_win, &angles[0], &angles[1]))
 507      angles[0] %= 360;
 508    else
 509      angles[0] = 0;
 510
 511    zone = at_mb->bd->zone;
 512
 513    if (REGION_INSIDE_ZONE(at_mb, zone)) state = EINA_TRUE;
 514    else state = EINA_FALSE;
 515
 516    if (state && at_mb->visible)
 517      {
 518         switch (angles[0])
 519           {
 520            case   0:
 521               x = 0;
 522               y = at_mb->h * -1;
 523               break;
 524            case  90:
 525               x = at_mb->w * -1;
 526               y = 0;
 527               break;
 528            case 180:
 529               x = 0;
 530               y = zone->h;
 531               break;
 532            case 270:
 533               x = zone->w;
 534               y = 0;
 535               break;
 536            default :
 537               x = 0;
 538               y = at_mb->h * -1;
 539               break;
 540           }
 541
 542         if (e_mod_move_apptray_objs_animation_state_get(at_mb))
 543           {
 544              e_mod_move_apptray_objs_animation_stop(at_mb);
 545              e_mod_move_apptray_objs_animation_clear(at_mb);
 546           }
 547         e_mod_move_apptray_objs_add(at_mb);
 548
 549         // send apptray to "move start message".
 550         e_mod_move_apptray_anim_state_send(at_mb, EINA_TRUE);
 551
 552         // apptray_objs_animation_layer_set
 553         e_mod_move_apptray_objs_animation_layer_set(at_mb);
 554
 555         e_mod_move_apptray_e_border_move(at_mb, x, y);
 556         e_mod_move_apptray_objs_animation_move(at_mb, x, y);
 557      }
 558
 559    return ECORE_CALLBACK_PASS_ON;
 560 }
 561
 562 static void
 563 _e_mod_move_apptray_bg_touch_win_show(E_Move_Border *mb)
 564 {
 565    E_Move_Apptray_Data *at_data = NULL;
 566    E_Border *bd = NULL;
 567    E_Zone *zone = NULL;
 568
 569    E_CHECK(mb);
 570    E_CHECK(TYPE_APPTRAY_CHECK(mb));
 571    at_data = (E_Move_Apptray_Data *)mb->data;
 572
 573    bd = mb->bd;
 574    zone = bd->zone;
 575
 576    E_CHECK(at_data);
 577
 578    if (at_data->bg_touch.win) return;
 579
 580    at_data->bg_touch.win =  ecore_x_window_input_new(0, zone->x, zone->y,
 581                                                      zone->w, zone->h);
 582    ecore_x_icccm_title_set(at_data->bg_touch.win, "E MOVE Apptray BG Touch");
 583    ecore_x_window_show(at_data->bg_touch.win);
 584
 585    at_data->bg_touch.dn_h = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN,
 586                                                     _e_mod_move_apptray_cb_bg_touch_dn,
 587                                                     (void*)at_data);
 588    at_data->bg_touch.up_h = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP,
 589                                                     _e_mod_move_apptray_cb_bg_touch_up,
 590                                                     (void*)at_data);
 591
 592    // Stack re-arrange
 593    ecore_x_window_configure(at_data->bg_touch.win,
 594                             ECORE_X_WINDOW_CONFIGURE_MASK_SIBLING |
 595                             ECORE_X_WINDOW_CONFIGURE_MASK_STACK_MODE,
 596                             zone->x, zone->y,
 597                             zone->w, zone->h, 0,
 598                             bd->win, ECORE_X_WINDOW_STACK_BELOW);
 599 }
 600
 601 static void
 602 _e_mod_move_apptray_bg_touch_win_hide(E_Move_Border *mb)
 603 {
 604    E_Move_Apptray_Data *at_data = NULL;
 605
 606    E_CHECK(mb);
 607    E_CHECK(TYPE_APPTRAY_CHECK(mb));
 608    at_data = (E_Move_Apptray_Data *)mb->data;
 609
 610    E_CHECK(at_data);
 611
 612    E_CHECK(at_data->bg_touch.win);
 613
 614    if (at_data->bg_touch.dn_h)
 615      {
 616         ecore_event_handler_del(at_data->bg_touch.dn_h);
 617         at_data->bg_touch.dn_h = NULL;
 618      }
 619    if (at_data->bg_touch.up_h)
 620      {
 621         ecore_event_handler_del(at_data->bg_touch.up_h);
 622         at_data->bg_touch.up_h = NULL;
 623      }
 624
 625    ecore_x_window_hide(at_data->bg_touch.win);
 626    ecore_x_window_free(at_data->bg_touch.win);
 627    at_data->bg_touch.win = 0;
 628 }
 629
 630 static Ecore_X_Window
 631 _e_mod_move_apptray_bg_touch_win_get(E_Move_Border *mb)
 632 {
 633    E_Move_Apptray_Data *at_data = NULL;
 634
 635    E_CHECK_RETURN(mb, 0);
 636    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), 0);
 637    at_data = (E_Move_Apptray_Data *)mb->data;
 638
 639    E_CHECK_RETURN(at_data, 0);
 640
 641    E_CHECK_RETURN(at_data->bg_touch.win, 0);
 642
 643    return at_data->bg_touch.win;
 644 }
 645
 646 /* externally accessible functions */
 647 EINTERN void
 648 e_mod_move_apptray_ctl_obj_event_setup(E_Move_Border         *mb,
 649                                        E_Move_Control_Object *mco)
 650 {
 651    E_CHECK(mb);
 652    E_CHECK(mco);
 653    E_CHECK(TYPE_APPTRAY_CHECK(mb));
 654
 655    mco->event = e_mod_move_event_new(mb->bd->client.win, mco->obj);
 656    E_CHECK(mco->event);
 657
 658    e_mod_move_event_data_type_set(mco->event, E_MOVE_EVENT_DATA_TYPE_BORDER);
 659    e_mod_move_event_angle_cb_set(mco->event,
 660                                  e_mod_move_util_win_prop_angle_get);
 661    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_START,
 662                            _e_mod_move_apptray_cb_motion_start, mb);
 663    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_MOVE,
 664                            _e_mod_move_apptray_cb_motion_move, mb);
 665    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_END,
 666                            _e_mod_move_apptray_cb_motion_end, mb);
 667    e_mod_move_event_propagate_type_set(mco->event,
 668                                        E_MOVE_EVENT_PROPAGATE_TYPE_IMMEDIATELY);
 669 }
 670
 671 EINTERN E_Move_Border *
 672 e_mod_move_apptray_find(void)
 673 {
 674    E_Move *m;
 675    E_Move_Border *mb;
 676
 677    m = e_mod_move_util_get();
 678    E_CHECK_RETURN(m, 0);
 679
 680    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 681      {
 682         if (TYPE_APPTRAY_CHECK(mb)) return mb;
 683      }
 684    return NULL;
 685 }
 686
 687 EINTERN Eina_Bool
 688 e_mod_move_apptray_click_get(void)
 689 {
 690    E_Move_Border         *mb = NULL;
 691    Eina_Bool              click = EINA_FALSE;
 692    E_Move_Control_Object *mco = NULL;
 693    Eina_List             *l;
 694
 695    mb = e_mod_move_apptray_find();
 696    E_CHECK_RETURN(mb, EINA_FALSE);
 697
 698    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 699      {
 700         if (!mco) continue;
 701         click = e_mod_move_event_click_get(mco->event);
 702      }
 703
 704    return click;
 705 }
 706
 707 EINTERN Eina_Bool
 708 e_mod_move_apptray_event_clear(void)
 709 {
 710    E_Move_Border         *mb = NULL;
 711    Eina_Bool              click = EINA_FALSE;
 712    E_Move_Control_Object *mco = NULL;
 713    Eina_List             *l;
 714
 715    mb = e_mod_move_apptray_find();
 716    E_CHECK_RETURN(mb, EINA_FALSE);
 717
 718    click = e_mod_move_apptray_click_get();
 719    E_CHECK_RETURN(click, EINA_FALSE);
 720
 721    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 722      {
 723         if (!mco) continue;
 724         e_mod_move_event_data_clear(mco->event);
 725         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 726      }
 727
 728    if (mb->flick_data) e_mod_move_flick_data_free(mb);
 729
 730    return EINA_TRUE;
 731 }
 732
 733 EINTERN Eina_Bool
 734 e_mod_move_apptray_objs_add(E_Move_Border *mb)
 735 {
 736    Eina_Bool mirror = EINA_TRUE;
 737    E_CHECK_RETURN(mb, EINA_FALSE);
 738    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 739
 740    if (!(mb->objs))
 741      {
 742         mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
 743         e_mod_move_bd_move_objs_move(mb, mb->x, mb->y);
 744         e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
 745         e_mod_move_bd_move_objs_show(mb);
 746         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
 747      }
 748    return EINA_TRUE;
 749 }
 750
 751 EINTERN Eina_Bool
 752 e_mod_move_apptray_objs_del(E_Move_Border *mb)
 753 {
 754    E_CHECK_RETURN(mb, EINA_FALSE);
 755    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 756    e_mod_move_bd_move_objs_del(mb, mb->objs);
 757    e_mod_move_util_rotation_unlock(mb->m);
 758    mb->objs = NULL;
 759    return EINA_TRUE;
 760 }
 761
 762 EINTERN Eina_Bool
 763 e_mod_move_apptray_objs_move(E_Move_Border *mb,
 764                              int            x,
 765                              int            y)
 766 {
 767    E_CHECK_RETURN(mb, EINA_FALSE);
 768    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 769
 770    e_mod_move_bd_move_objs_move(mb, x, y);
 771    _e_mod_move_apptray_objs_position_set(mb, x, y);
 772    _e_mod_move_apptray_dim_objs_apply(mb, x, y);
 773    return EINA_TRUE;
 774 }
 775
 776 EINTERN Eina_Bool
 777 e_mod_move_apptray_objs_raise(E_Move_Border *mb)
 778 {
 779    E_CHECK_RETURN(mb, EINA_FALSE);
 780    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 781    e_mod_move_bd_move_objs_raise(mb);
 782    return EINA_TRUE;
 783 }
 784
 785 EINTERN Eina_Bool
 786 e_mod_move_apptray_objs_animation_move(E_Move_Border *mb,
 787                                        int            x,
 788                                        int            y)
 789 {
 790    E_Move_Apptray_Animation_Data *anim_data = NULL;
 791    Ecore_Animator *animator = NULL;
 792    int sx, sy; //start x, start y
 793    double anim_time = 0.0;
 794
 795    E_CHECK_RETURN(mb, EINA_FALSE);
 796    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 797    E_CHECK_RETURN(mb->m, EINA_FALSE);
 798    anim_time = mb->m->animation_duration;
 799
 800    if (e_mod_move_apptray_objs_animation_state_get(mb))
 801      {
 802         e_mod_move_apptray_objs_animation_stop(mb);
 803         e_mod_move_apptray_objs_animation_clear(mb);
 804      }
 805
 806    anim_data = E_NEW(E_Move_Apptray_Animation_Data, 1);
 807    E_CHECK_RETURN(anim_data, EINA_FALSE);
 808
 809    if (_e_mod_move_apptray_objs_position_get(mb, &sx, &sy))
 810      {
 811         anim_data->sx = sx;
 812         anim_data->sy = sy;
 813      }
 814    else
 815      {
 816         anim_data->sx = mb->x;
 817         anim_data->sy = mb->y;
 818         _e_mod_move_apptray_objs_position_set(mb,
 819                                               anim_data->sx,
 820                                               anim_data->sy);
 821      }
 822
 823    anim_data->ex = x;
 824    anim_data->ey = y;
 825    anim_data->dx = anim_data->ex - anim_data->sx;
 826    anim_data->dy = anim_data->ey - anim_data->sy;
 827    animator = ecore_animator_timeline_add(anim_time,
 828                                           _e_mod_move_apptray_objs_animation_frame,
 829                                           anim_data);
 830    if (!animator)
 831      {
 832         memset(anim_data, 0, sizeof(E_Move_Apptray_Animation_Data));
 833         E_FREE(anim_data);
 834         return EINA_FALSE;
 835      }
 836
 837    anim_data->animator = animator;
 838    anim_data->animating = EINA_TRUE;
 839    mb->anim_data = anim_data;
 840    return EINA_TRUE;
 841 }
 842
 843 EINTERN Eina_Bool
 844 e_mod_move_apptray_objs_animation_state_get(E_Move_Border *mb)
 845 {
 846    E_Move_Apptray_Animation_Data *anim_data = NULL;
 847    E_CHECK_RETURN(mb, EINA_FALSE);
 848    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 849
 850    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 851    anim_data = (E_Move_Apptray_Animation_Data *)mb->anim_data;
 852    E_CHECK_RETURN(anim_data->animating, EINA_FALSE);
 853    return EINA_TRUE;
 854 }
 855
 856 EINTERN Eina_Bool
 857 e_mod_move_apptray_objs_animation_stop(E_Move_Border *mb)
 858 {
 859    E_Move_Apptray_Animation_Data *anim_data = NULL;
 860    E_CHECK_RETURN(mb, EINA_FALSE);
 861    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 862
 863    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 864    anim_data = (E_Move_Apptray_Animation_Data *)mb->anim_data;
 865    ecore_animator_freeze(anim_data->animator);
 866    return EINA_TRUE;
 867 }
 868
 869 EINTERN Eina_Bool
 870 e_mod_move_apptray_objs_animation_clear(E_Move_Border *mb)
 871 {
 872    E_Move_Apptray_Animation_Data *anim_data = NULL;
 873    E_CHECK_RETURN(mb, EINA_FALSE);
 874    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 875
 876    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 877    anim_data = (E_Move_Apptray_Animation_Data *)mb->anim_data;
 878    ecore_animator_del(anim_data->animator);
 879    memset(anim_data, 0, sizeof(E_Move_Apptray_Animation_Data));
 880    E_FREE(anim_data);
 881    mb->anim_data = NULL;
 882
 883    return EINA_TRUE;
 884 }
 885
 886 EINTERN void*
 887 e_mod_move_apptray_internal_data_add(E_Move_Border *mb)
 888 {
 889    E_Move_Apptray_Data *at_data = NULL;
 890    int dim_min = 0;
 891    E_CHECK_RETURN(mb, NULL);
 892    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), NULL);
 893    E_CHECK_RETURN(mb->m, NULL);
 894    at_data = (E_Move_Apptray_Data *)mb->data;
 895    dim_min = mb->m->dim_min_opacity;
 896    if (!at_data)
 897      {
 898         at_data = E_NEW(E_Move_Apptray_Data, 1);
 899         E_CHECK_RETURN(at_data, NULL);
 900         at_data->x = mb->x;
 901         at_data->y = mb->y;
 902         at_data->dim_objs = NULL;
 903         at_data->opacity = dim_min;
 904         mb->data = at_data;
 905      }
 906    return mb->data;
 907 }
 908
 909 EINTERN Eina_Bool
 910 e_mod_move_apptray_internal_data_del(E_Move_Border *mb)
 911 {
 912    E_Move_Apptray_Data *at_data = NULL;
 913    E_CHECK_RETURN(mb, EINA_FALSE);
 914    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 915    E_CHECK_RETURN(mb->data, EINA_FALSE);
 916    at_data = (E_Move_Apptray_Data *)mb->data;
 917    e_mod_move_apptray_dim_hide(mb);
 918    E_FREE(at_data);
 919    mb->data = NULL;
 920    return EINA_TRUE;
 921 }
 922
 923 EINTERN Eina_Bool
 924 e_mod_move_apptray_e_border_move(E_Move_Border *mb,
 925                                  int            x,
 926                                  int            y)
 927 {
 928    E_Zone *zone;
 929
 930    E_CHECK_RETURN(mb, EINA_FALSE);
 931    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 932    E_CHECK_RETURN(mb->bd, EINA_FALSE);
 933
 934    zone = mb->bd->zone;
 935
 936    /* check whether zone contains border */
 937    if (E_CONTAINS(zone->x, zone->y,
 938                   zone->w, zone->h,
 939                   x, y, mb->w, mb->h))
 940      {
 941         e_border_raise(mb->bd);
 942         e_border_focus_set(mb->bd, 1, 1);
 943      }
 944    else
 945      {
 946         e_border_focus_set(mb->bd, 0, 0);
 947      }
 948
 949    e_border_move(mb->bd, x, y);
 950
 951    return EINA_TRUE;
 952 }
 953
 954 EINTERN Eina_Bool
 955 e_mod_move_apptray_e_border_raise(E_Move_Border *mb)
 956 {
 957    E_CHECK_RETURN(mb, EINA_FALSE);
 958    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 959
 960    e_border_raise(mb->bd);
 961
 962    return EINA_TRUE;
 963 }
 964
 965 EINTERN Eina_Bool
 966 e_mod_move_apptray_e_border_lower(E_Move_Border *mb)
 967 {
 968    E_CHECK_RETURN(mb, EINA_FALSE);
 969    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
 970
 971    e_border_lower(mb->bd);
 972
 973    return EINA_TRUE;
 974 }
 975
 976 EINTERN Eina_List*
 977 e_mod_move_apptray_dim_show(E_Move_Border *mb)
 978 {
 979    int dim_min = 0;
 980    E_Move_Apptray_Data *at_data = NULL;
 981    E_CHECK_RETURN(mb, NULL);
 982    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), NULL);
 983    E_CHECK_RETURN(mb->m, NULL);
 984    at_data = (E_Move_Apptray_Data *)mb->data;
 985    dim_min = mb->m->dim_min_opacity;
 986    if (!at_data)
 987      {
 988         at_data = E_NEW(E_Move_Apptray_Data, 1);
 989         E_CHECK_RETURN(at_data, NULL);
 990         // Composite mode set true
 991         e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_TRUE);
 992
 993         at_data->x = mb->x;
 994         at_data->y = mb->y;
 995         at_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
 996         e_mod_move_bd_move_dim_objs_show(at_data->dim_objs);
 997         at_data->opacity = dim_min;
 998         mb->data = at_data;
 999
1000         // it is used for apptray input only window
1001         _e_mod_move_apptray_bg_touch_win_show(mb);
1002      }
1003    else
1004      {
1005         if (!(at_data->dim_objs))
1006           {
1007              // Composite mode set true
1008              e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_TRUE);
1009
1010              at_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
1011           }
1012         if (at_data->dim_objs)
1013           {
1014              e_mod_move_bd_move_dim_objs_show(at_data->dim_objs);
1015              at_data->opacity = dim_min;
1016           }
1017
1018         // it is used for apptray input only window
1019         _e_mod_move_apptray_bg_touch_win_show(mb);
1020      }
1021
1022    L(LT_EVENT_OBJ,
1023      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
1024      "EVAS_OBJ", mb->bd->win, __func__);
1025
1026    return at_data->dim_objs;
1027 }
1028
1029 EINTERN Eina_Bool
1030 e_mod_move_apptray_dim_hide(E_Move_Border *mb)
1031 {
1032    int dim_min = 0;
1033    E_Move_Apptray_Data *at_data = NULL;
1034    E_CHECK_RETURN(mb, EINA_FALSE);
1035    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1036    E_CHECK_RETURN(mb->m, EINA_FALSE);
1037    E_CHECK_RETURN(mb->data, EINA_FALSE);
1038    at_data = (E_Move_Apptray_Data *)mb->data;
1039    dim_min = mb->m->dim_min_opacity;
1040    E_CHECK_RETURN(at_data->dim_objs, EINA_FALSE);
1041    e_mod_move_bd_move_dim_objs_hide(at_data->dim_objs);
1042    e_mod_move_bd_move_dim_objs_del(at_data->dim_objs);
1043    at_data->dim_objs = NULL;
1044    at_data->opacity = dim_min;
1045
1046    // it is used for apptray input only window
1047    _e_mod_move_apptray_bg_touch_win_hide(mb);
1048
1049    // Composite mode set false
1050    e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_FALSE);
1051
1052    L(LT_EVENT_OBJ,
1053      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
1054      "EVAS_OBJ", ((mb->bd) ? mb->bd->win : NULL), __func__);
1055
1056    return EINA_TRUE;
1057 }
1058
1059 EINTERN Eina_Bool
1060 e_mod_move_apptray_restack_post_process(E_Move_Border *mb)
1061 {
1062    Ecore_X_Window win;
1063    E_Border      *bd = NULL;
1064    E_Zone        *zone = NULL;
1065
1066    E_CHECK_RETURN(mb, EINA_FALSE);
1067    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1068
1069    bd = mb->bd;
1070    E_CHECK_RETURN(bd, EINA_FALSE);
1071    zone = bd->zone;
1072    E_CHECK_RETURN(zone, EINA_FALSE);
1073
1074    if ((win = _e_mod_move_apptray_bg_touch_win_get(mb)))
1075      {
1076         // Stack re-arrange
1077         ecore_x_window_configure(win,
1078                                  ECORE_X_WINDOW_CONFIGURE_MASK_SIBLING |
1079                                  ECORE_X_WINDOW_CONFIGURE_MASK_STACK_MODE,
1080                                  zone->x, zone->y,
1081                                  zone->w, zone->h, 0,
1082                                  bd->win, ECORE_X_WINDOW_STACK_BELOW);
1083      }
1084    return EINA_TRUE;
1085 }
1086
1087 EINTERN Eina_Bool
1088 e_mod_move_apptray_objs_animation_start_position_set(E_Move_Border *mb,
1089                                                      int            angle)
1090 {
1091    E_Zone *zone;
1092    int x, y;
1093
1094    E_CHECK_RETURN(mb, EINA_FALSE);
1095    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1096
1097    angle = ((angle % 360) / 90) * 90;
1098    zone = mb->bd->zone;
1099
1100    switch (angle)
1101      {
1102       case  90: x = mb->w * -1;        y = 0;                 break;
1103       case 180: x = 0;                 y = zone->y + zone->h; break;
1104       case 270: x = zone->x + zone->w; y = 0;                 break;
1105       case   0:
1106       default : x = 0;                 y = mb->h * -1;        break;
1107      }
1108
1109    _e_mod_move_apptray_objs_position_set(mb, x, y);
1110
1111    return EINA_TRUE;
1112 }
1113
1114 EINTERN E_Move_Event_Cb
1115 e_mod_move_apptray_event_cb_get(E_Move_Event_Type type)
1116 {
1117    if (type == E_MOVE_EVENT_TYPE_MOTION_START)
1118      return _e_mod_move_apptray_cb_motion_start;
1119    else if (type == E_MOVE_EVENT_TYPE_MOTION_MOVE)
1120      return _e_mod_move_apptray_cb_motion_move;
1121    else if (type == E_MOVE_EVENT_TYPE_MOTION_END)
1122      return _e_mod_move_apptray_cb_motion_end;
1123    else
1124      return NULL;
1125 }
1126
1127 EINTERN Eina_Bool
1128 e_mod_move_apptray_anim_state_send(E_Move_Border *mb,
1129                                    Eina_Bool state)
1130 {
1131    long d[5] = {0L, 0L, 0L, 0L, 0L};
1132    Ecore_X_Window win;
1133    E_CHECK_RETURN(mb, EINA_FALSE);
1134    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1135
1136    win = e_mod_move_util_client_xid_get(mb);
1137    E_CHECK_RETURN(win, 0);
1138
1139    if (state) d[0] = 1L;
1140    else d[0] = 0L;
1141
1142    ecore_x_client_message32_send
1143      (win, ATOM_MV_APPTRAY_STATE,
1144      ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
1145      d[0], d[1], d[2], d[3], d[4]);
1146
1147    return EINA_TRUE;
1148 }
1149
1150 EINTERN Eina_Bool
1151 e_mod_move_apptray_objs_animation_layer_set(E_Move_Border *mb)
1152 {
1153    E_Move              *m = e_mod_move_util_get();
1154    E_Move_Border       *find_mb = NULL;
1155    E_Move_Border       *indi_mb = NULL;
1156    E_Move_Border       *state_above_mb = NULL;
1157    E_Zone              *zone = NULL;
1158    Ecore_X_Window       win;
1159    Eina_Bool            found = EINA_FALSE;
1160    E_Move_Apptray_Data *at_data = NULL;
1161
1162    E_CHECK_RETURN(m, EINA_FALSE);
1163    E_CHECK_RETURN(mb, EINA_FALSE);
1164    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1165
1166    at_data = (E_Move_Apptray_Data *)mb->data;
1167    E_CHECK_RETURN(at_data, EINA_FALSE);
1168
1169    at_data->animation_layer_info.indicator.layer_set = EINA_FALSE;
1170    at_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1171    at_data->animation_layer_info.state_above.win = 0;
1172
1173    EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
1174      {
1175         if (find_mb->bd
1176             && (find_mb->bd->layer == e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER))
1177             && (find_mb->visible))
1178           {
1179              win = find_mb->bd->client.win;
1180              found = EINA_TRUE;
1181           }
1182
1183         if (find_mb->bd
1184             && (find_mb->bd->layer < e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER)))
1185           {
1186              break;
1187           }
1188      }
1189
1190    if (found)
1191      {
1192         at_data->animation_layer_info.state_above.layer_set = EINA_TRUE;
1193         at_data->animation_layer_info.state_above.win = win;
1194         state_above_mb = e_mod_move_border_client_find(win);
1195         if (state_above_mb
1196             && !(state_above_mb->objs))
1197           {
1198              state_above_mb->objs = e_mod_move_bd_move_objs_add(state_above_mb, EINA_TRUE);
1199              e_mod_move_bd_move_objs_move(state_above_mb, state_above_mb->x, state_above_mb->y);
1200              e_mod_move_bd_move_objs_resize(state_above_mb, state_above_mb->w, state_above_mb->h);
1201              e_mod_move_bd_move_objs_show(state_above_mb);
1202           }
1203
1204         // apptray mirror object stack below to state_above object .
1205         e_mod_move_bd_move_objs_stack_below(mb, state_above_mb); // mb : apptray move border
1206
1207         // indicator window mirror object stack control
1208         indi_mb = e_mod_move_indicator_find();
1209         zone = mb->bd->zone;
1210         if ((indi_mb)
1211             && (indi_mb->visible)
1212             && (REGION_INSIDE_ZONE(indi_mb, zone))
1213             && (!m->elm_indicator_mode))
1214           {
1215              at_data->animation_layer_info.indicator.layer_set = EINA_TRUE;
1216              if (!(indi_mb->objs))
1217                {
1218                   indi_mb->objs = e_mod_move_bd_move_objs_add(indi_mb, EINA_TRUE);
1219                   e_mod_move_bd_move_objs_move(indi_mb, indi_mb->x, indi_mb->y);
1220                   e_mod_move_bd_move_objs_resize(indi_mb, indi_mb->w, indi_mb->h);
1221                   e_mod_move_bd_move_objs_show(indi_mb);
1222                }
1223
1224              // indicator mirror object stack below to apptray.
1225              e_mod_move_bd_move_objs_stack_below(indi_mb, mb); // mb : apptray move border
1226           }
1227      }
1228    else
1229      {
1230         e_mod_move_apptray_objs_raise(mb);
1231      }
1232
1233    return EINA_TRUE;
1234 }
1235
1236 EINTERN Eina_Bool
1237 e_mod_move_apptray_objs_animation_layer_unset(E_Move_Border *mb)
1238 {
1239    E_Move_Border       *indi_mb = NULL;
1240    E_Move_Border       *state_above_mb = NULL;
1241    E_Move_Apptray_Data *at_data = NULL;
1242    Ecore_X_Window       win;
1243
1244    E_CHECK_RETURN(mb, EINA_FALSE);
1245    E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
1246
1247    at_data = (E_Move_Apptray_Data *)mb->data;
1248    E_CHECK_RETURN(at_data, EINA_FALSE);
1249
1250    if (at_data->animation_layer_info.indicator.layer_set)
1251      {
1252         if ((indi_mb = e_mod_move_indicator_find())
1253              && (!indi_mb->animate_move))
1254           {
1255              e_mod_move_bd_move_objs_del(indi_mb, indi_mb->objs);
1256              indi_mb->objs = NULL;
1257           }
1258      }
1259
1260    if (at_data->animation_layer_info.state_above.layer_set)
1261      {
1262         win = at_data->animation_layer_info.state_above.win;
1263         if ((state_above_mb = e_mod_move_border_client_find(win))
1264             && (!state_above_mb->animate_move))
1265           {
1266              e_mod_move_bd_move_objs_del(state_above_mb, state_above_mb->objs);
1267              state_above_mb->objs = NULL;
1268           }
1269      }
1270
1271    at_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1272    at_data->animation_layer_info.indicator.layer_set = EINA_FALSE;
1273    at_data->animation_layer_info.state_above.win = 0;
1274
1275    return EINA_TRUE;
1276 }