move-tizen/src/e_mod_move_mini_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_Mini_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_mini_apptray_cb_motion_start(void *data, void *event_info);
  20 static Eina_Bool      _e_mod_move_mini_apptray_cb_motion_move(void *data, void *event_info);
  21 static Eina_Bool      _e_mod_move_mini_apptray_cb_motion_end(void *data, void *event_info);
  22 static Eina_Bool      _e_mod_move_mini_apptray_objs_position_set(E_Move_Border *mb, int x, int y);
  23 static Eina_Bool      _e_mod_move_mini_apptray_objs_position_get(E_Move_Border *mb, int *x, int *y);
  24 static Eina_Bool      _e_mod_move_mini_apptray_objs_animation_frame(void  *data, double pos);
  25 static Eina_Bool      _e_mod_move_mini_apptray_flick_process(E_Move_Border *mb, int angle, Eina_Bool state);
  26 static Eina_Bool      _e_mod_move_mini_apptray_dim_objs_apply(E_Move_Border *mb, int x, int y);
  27 static Eina_Bool      _e_mod_move_mini_apptray_ctl_event_send_policy_check(E_Move_Border *mb, Evas_Point pos);
  28
  29 /* local subsystem functions */
  30 static Eina_Bool
  31 _e_mod_move_mini_apptray_cb_motion_start(void *data,
  32                                          void *event_info)
  33 {
  34    E_Move_Border *mb = (E_Move_Border *)data;
  35    E_Move_Event_Motion_Info *info;
  36    E_Move_Control_Object *mco = NULL;
  37    Evas_Event_Mouse_Down *mouse_down_event = NULL;
  38    Eina_Bool clicked = EINA_FALSE;
  39    Eina_List *l;
  40    int angle = 0;
  41
  42    info  = (E_Move_Event_Motion_Info *)event_info;
  43    if (!mb || !info) return EINA_FALSE;
  44
  45    mouse_down_event = info->event_info;
  46    E_CHECK_RETURN(mouse_down_event, EINA_FALSE);
  47    if (mouse_down_event->button != 1)
  48      return EINA_FALSE;
  49
  50    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  51      {
  52         if (!mco) continue;
  53         clicked = e_mod_move_event_click_get(mco->event);
  54      }
  55    if (clicked)
  56      return EINA_FALSE;
  57
  58    L(LT_EVENT_OBJ,
  59      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
  60      "EVAS_OBJ", mb->bd->win, __func__);
  61
  62    if (e_mod_move_mini_apptray_objs_animation_state_get(mb)) goto error_cleanup;
  63
  64    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  65      {
  66         if (!mco) continue;
  67         angle = e_mod_move_event_angle_get(mco->event);
  68      }
  69    mb->angle = angle;
  70
  71    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  72      {
  73         if (!mco) continue;
  74         e_mod_move_event_click_set(mco->event, EINA_TRUE);
  75      }
  76
  77    E_CHECK_GOTO(mb->visible, error_cleanup);
  78    if (!REGION_INSIDE_ZONE(mb, mb->bd->zone))
  79       goto error_cleanup;
  80
  81    E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
  82    e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
  83
  84    e_mod_move_mini_apptray_objs_add(mb);
  85
  86    // send mini_apptray to "move start message".
  87    e_mod_move_mini_apptray_anim_state_send(mb, EINA_TRUE);
  88    return EINA_TRUE;
  89
  90 error_cleanup:
  91    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  92      {
  93         if (!mco) continue;
  94         e_mod_move_event_click_set(mco->event, EINA_FALSE);
  95      }
  96    return EINA_FALSE;
  97 }
  98
  99 static Eina_Bool
 100 _e_mod_move_mini_apptray_cb_motion_move(void *data,
 101                                         void *event_info)
 102 {
 103    E_Move_Border *mb = (E_Move_Border *)data;
 104    E_Move_Event_Motion_Info *info;
 105    E_Move_Control_Object *mco = NULL;
 106    Eina_List *l;
 107    int angle = 0;
 108    Eina_Bool click = EINA_FALSE;
 109    E_Zone *zone = NULL;
 110    int x = 0, y = 0;
 111    int cx, cy, cw, ch;
 112    Eina_Bool contents_region = EINA_FALSE;
 113
 114    info  = (E_Move_Event_Motion_Info *)event_info;
 115    if (!mb || !info) return EINA_FALSE;
 116
 117    SL(LT_EVENT_OBJ,
 118       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 119       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 120       __func__);
 121
 122    angle = mb->angle;
 123    zone = mb->bd->zone;
 124
 125    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 126      {
 127         if (!mco) continue;
 128         click = e_mod_move_event_click_get(mco->event);
 129      }
 130    E_CHECK_RETURN(click, EINA_FALSE);
 131
 132    if (_e_mod_move_mini_apptray_ctl_event_send_policy_check(mb, info->coord))
 133      {
 134         EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 135           {
 136              if (!mco) continue;
 137              e_mod_move_event_propagate_type_set(mco->event, E_MOVE_EVENT_PROPAGATE_TYPE_IMMEDIATELY);
 138           }
 139      }
 140    else
 141      {
 142         EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 143           {
 144              if (!mco) continue;
 145              e_mod_move_event_propagate_type_set(mco->event, E_MOVE_EVENT_PROPAGATE_TYPE_NONE);
 146           }
 147      }
 148
 149    contents_region = e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch);
 150
 151    switch (angle)
 152      {
 153       case   0:
 154          if (info->coord.y > (zone->h - mb->h))
 155            {
 156               if (contents_region)
 157                 {
 158                    if (info->coord.y > cy) y =  info->coord.y - cy;
 159                 }
 160               else
 161                 {
 162                    y =  info->coord.y;
 163                 }
 164            }
 165          break;
 166       case  90:
 167          if (info->coord.x > (zone->w - mb->w))
 168            {
 169               if (contents_region)
 170                 {
 171                    if (info->coord.x > cx) x = info->coord.x - cx;
 172                 }
 173               else
 174                 {
 175                    x = info->coord.x;
 176                 }
 177            }
 178          break;
 179       case 180:
 180          if (info->coord.y < mb->h)
 181            {
 182               if (contents_region)
 183                 {
 184                    if (info->coord.y < ch) y = info->coord.y - ch;
 185                 }
 186               else
 187                 {
 188                    y = info->coord.y - mb->h;
 189                 }
 190            }
 191          break;
 192       case 270:
 193          if (info->coord.x < mb->w)
 194            {
 195               if (contents_region)
 196                 {
 197                    if (info->coord.x < cw) x = info->coord.x - cw;
 198                 }
 199               else
 200                 {
 201                    x = info->coord.x - mb->w;
 202                 }
 203            }
 204          break;
 205       default :
 206          break;
 207      }
 208
 209    e_mod_move_mini_apptray_objs_move(mb, x, y);
 210
 211    return EINA_TRUE;
 212 }
 213
 214 static Eina_Bool
 215 _e_mod_move_mini_apptray_cb_motion_end(void *data,
 216                                        void *event_info)
 217 {
 218    E_Move_Border *mb = (E_Move_Border *)data;
 219    E_Move_Event_Motion_Info *info;
 220    E_Move_Control_Object *mco = NULL;
 221    Eina_List *l;
 222    int angle = 0;
 223    E_Zone *zone = NULL;
 224    Eina_Bool click = EINA_FALSE;
 225    Eina_Bool flick_state = EINA_FALSE;
 226    Evas_Event_Mouse_Up *mouse_up_event;
 227    int check_w, check_h;
 228
 229    info  = (E_Move_Event_Motion_Info *)event_info;
 230    if (!mb || !info) return EINA_FALSE;
 231
 232    mouse_up_event = info->event_info;
 233    E_CHECK_RETURN(mouse_up_event, EINA_FALSE);
 234    if (mouse_up_event->button != 1)
 235      return EINA_FALSE;
 236
 237    SL(LT_EVENT_OBJ,
 238       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 239       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 240       __func__);
 241
 242    angle = mb->angle;
 243    zone = mb->bd->zone;
 244
 245    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 246      {
 247         if (!mco) continue;
 248         click = e_mod_move_event_click_get(mco->event);
 249      }
 250    E_CHECK_GOTO(click, finish);
 251
 252    // event send all set
 253    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 254      {
 255         if (!mco) continue;
 256         e_mod_move_event_propagate_type_set(mco->event, E_MOVE_EVENT_PROPAGATE_TYPE_IMMEDIATELY);
 257      }
 258
 259    e_mod_move_flick_data_update(mb, info->coord.x, info->coord.y);
 260    flick_state = e_mod_move_flick_state_get(mb, EINA_FALSE);
 261    if (_e_mod_move_mini_apptray_flick_process(mb, angle, flick_state))
 262      {
 263         return EINA_TRUE;
 264      }
 265
 266    switch (angle)
 267      {
 268       case   0:
 269          check_h = mb->h;
 270          if (check_h) check_h /= 2;
 271          if (info->coord.y > (zone->h - check_h))
 272            {
 273               e_mod_move_mini_apptray_e_border_move(mb, 0, zone->h);
 274               e_mod_move_mini_apptray_objs_animation_move(mb, 0, zone->h);
 275            }
 276          else
 277            {
 278               e_mod_move_mini_apptray_objs_animation_move(mb, 0, (zone->h - mb->h));
 279            }
 280          break;
 281       case  90:
 282          check_w = mb->w;
 283          if (check_w) check_w /= 2;
 284          if (info->coord.x > (zone->w - check_w))
 285            {
 286               e_mod_move_mini_apptray_e_border_move(mb, zone->w, 0);
 287               e_mod_move_mini_apptray_objs_animation_move(mb, zone->w, 0);
 288            }
 289          else
 290            {
 291               e_mod_move_mini_apptray_objs_animation_move(mb, zone->w - mb->w, 0);
 292            }
 293          break;
 294       case 180:
 295          check_h = mb->y + mb->h;
 296          if (check_h) check_h /= 2;
 297          if (info->coord.y < check_h)
 298            {
 299               e_mod_move_mini_apptray_e_border_move(mb, 0, mb->h * -1);
 300               e_mod_move_mini_apptray_objs_animation_move(mb, 0, mb->h * -1);
 301            }
 302          else
 303            {
 304               e_mod_move_mini_apptray_objs_animation_move(mb, 0, 0);
 305            }
 306          break;
 307       case 270:
 308          check_w = mb->w;
 309          if (check_w) check_w /= 2;
 310          if (info->coord.x < check_w)
 311            {
 312               e_mod_move_mini_apptray_e_border_move(mb, mb->w * -1, 0);
 313               e_mod_move_mini_apptray_objs_animation_move(mb, mb->w * -1, 0);
 314            }
 315          else
 316            {
 317               e_mod_move_mini_apptray_objs_animation_move(mb, 0, 0);
 318            }
 319          break;
 320       default :
 321          break;
 322      }
 323
 324    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 325      {
 326         if (!mco) continue;
 327         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 328      }
 329
 330 finish:
 331    if (mb->flick_data) e_mod_move_flick_data_free(mb);
 332    return EINA_TRUE;
 333 }
 334
 335 static Eina_Bool
 336 _e_mod_move_mini_apptray_objs_position_set(E_Move_Border *mb,
 337                                            int            x,
 338                                            int            y)
 339 {
 340    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 341    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 342    if (!mini_apptray_data)
 343      mini_apptray_data = (E_Move_Mini_Apptray_Data *)e_mod_move_mini_apptray_internal_data_add(mb);
 344    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
 345
 346    mini_apptray_data->x = x;
 347    mini_apptray_data->y = y;
 348    mb->data = mini_apptray_data;
 349    return EINA_TRUE;
 350 }
 351
 352 static Eina_Bool
 353 _e_mod_move_mini_apptray_objs_position_get(E_Move_Border *mb,
 354                                            int           *x,
 355                                            int           *y)
 356 {
 357    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 358    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 359    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
 360
 361    *x = mini_apptray_data->x;
 362    *y = mini_apptray_data->y;
 363
 364    return EINA_TRUE;
 365 }
 366
 367 static Eina_Bool
 368 _e_mod_move_mini_apptray_objs_animation_frame(void  *data,
 369                                               double pos)
 370 {
 371    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 372    E_Move_Border                      *mb = NULL;
 373    double                              frame = pos;
 374    int                                 x, y;
 375
 376    anim_data = (E_Move_Mini_Apptray_Animation_Data *)data;
 377    E_CHECK_RETURN(anim_data, EINA_FALSE);
 378
 379    mb = e_mod_move_mini_apptray_find();
 380    E_CHECK_RETURN(mb, EINA_FALSE);
 381
 382    frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE, 0.0, 0.0);
 383    x = anim_data->sx + anim_data->dx * frame;
 384    y = anim_data->sy + anim_data->dy * frame;
 385
 386    e_mod_move_mini_apptray_objs_move(mb, x, y);
 387
 388    if (pos >= 1.0)
 389      {
 390         if (!(REGION_INSIDE_ZONE(mb, mb->bd->zone)))
 391           {
 392              e_border_focus_set(mb->bd, 0, 0);
 393              e_mod_move_mini_apptray_dim_hide(mb);
 394           }
 395
 396         // send mini_apptray to "move end message".
 397         e_mod_move_mini_apptray_anim_state_send(mb, EINA_FALSE);
 398
 399         e_mod_move_mini_apptray_objs_del(mb);
 400
 401         memset(anim_data, 0, sizeof(E_Move_Mini_Apptray_Animation_Data));
 402         E_FREE(anim_data);
 403         mb->anim_data = NULL;
 404      }
 405    return EINA_TRUE;
 406 }
 407
 408 static Eina_Bool
 409 _e_mod_move_mini_apptray_flick_process(E_Move_Border *mb,
 410                                        int            angle,
 411                                        Eina_Bool      state)
 412 {
 413    E_Move_Control_Object *mco = NULL;
 414    E_Zone *zone = NULL;
 415    Eina_List *l;
 416    int x, y;
 417
 418    E_CHECK_RETURN(mb, EINA_FALSE);
 419    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 420    E_CHECK_RETURN(state, EINA_FALSE);
 421
 422    zone = mb->bd->zone;
 423
 424    /* mini_apptray click unset */
 425    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 426      {
 427         if (!mco) continue;
 428         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 429      }
 430
 431    e_mod_move_flick_data_free(mb);
 432
 433    switch (angle)
 434      {
 435       case  90: x = zone->w;    y = 0;          break;
 436       case 180: x = 0;          y = mb->h * -1; break;
 437       case 270:    x = mb->w * -1; y = 0;       break;
 438       case   0:
 439       default : x = 0;          y = zone->h;    break;
 440      }
 441
 442    e_mod_move_mini_apptray_e_border_move(mb, x, y);
 443    e_mod_move_mini_apptray_objs_animation_move(mb, x, y);
 444
 445    return EINA_TRUE;
 446 }
 447
 448 static Eina_Bool
 449 _e_mod_move_mini_apptray_dim_objs_apply(E_Move_Border *mb,
 450                                         int            x,
 451                                         int            y)
 452 {
 453    int angle;
 454    int mx, my;
 455    int opacity;
 456    E_Zone *zone = NULL;
 457    int dim_max = 255;
 458    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 459
 460    E_CHECK_RETURN(mb, EINA_FALSE);
 461    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 462    E_CHECK_RETURN(mb->data, EINA_FALSE);
 463
 464    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 465    E_CHECK_RETURN(mini_apptray_data->dim_objs, EINA_FALSE);
 466
 467    angle = mb->angle;
 468    zone = mb->bd->zone;
 469    dim_max = mb->m->dim_max_opacity;
 470
 471    switch (angle)
 472      {
 473       case  90:
 474          mx = zone->w - x;
 475          if (mb->w)
 476            opacity = dim_max * mx / mb->w;
 477          else
 478            opacity = dim_max;
 479          break;
 480       case 180:
 481          my = y + mb->h;
 482          if (mb->h)
 483            opacity = dim_max * my / mb->h;
 484          else
 485            opacity = dim_max;
 486          break;
 487       case 270:
 488          mx = x + mb->w;
 489          if (mb->w)
 490            opacity = dim_max * mx / mb->w;
 491          else
 492            opacity = dim_max;
 493          break;
 494       case   0:
 495       default :
 496          my = zone->h - y;
 497          if (mb->h)
 498            opacity = dim_max * my / mb->h;
 499          else
 500            opacity = dim_max;
 501          break;
 502      }
 503
 504    e_mod_move_bd_move_dim_objs_opacity_set(mini_apptray_data->dim_objs, opacity);
 505    mini_apptray_data->opacity = opacity;
 506    return EINA_TRUE;
 507 }
 508
 509 static Eina_Bool
 510 _e_mod_move_mini_apptray_ctl_event_send_policy_check(E_Move_Border *mb,
 511                                                      Evas_Point     pos)
 512 {
 513    int x = 0, y = 0, w = 0, h = 0;
 514    Eina_Bool ret = EINA_FALSE;
 515
 516    E_CHECK_RETURN(mb, EINA_FALSE);
 517    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 518
 519    e_mod_move_bd_move_ctl_objs_geometry_get(mb, &x ,&y, &w, &h);
 520
 521    if (E_INSIDE(pos.x, pos.y, x, y, w, h)) ret = EINA_TRUE;
 522
 523    return ret;
 524 }
 525
 526 /* externally accessible functions */
 527 EINTERN void
 528 e_mod_move_mini_apptray_ctl_obj_event_setup(E_Move_Border         *mb,
 529                                             E_Move_Control_Object *mco)
 530 {
 531    E_CHECK(mb);
 532    E_CHECK(mco);
 533    E_CHECK(TYPE_MINI_APPTRAY_CHECK(mb));
 534
 535    mco->event = e_mod_move_event_new(mb->bd->client.win, mco->obj);
 536    E_CHECK(mco->event);
 537
 538    e_mod_move_event_data_type_set(mco->event, E_MOVE_EVENT_DATA_TYPE_BORDER);
 539    e_mod_move_event_angle_cb_set(mco->event,
 540                                  e_mod_move_util_win_prop_angle_get);
 541    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_START,
 542                            _e_mod_move_mini_apptray_cb_motion_start, mb);
 543    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_MOVE,
 544                            _e_mod_move_mini_apptray_cb_motion_move, mb);
 545    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_END,
 546                            _e_mod_move_mini_apptray_cb_motion_end, mb);
 547    e_mod_move_event_propagate_type_set(mco->event,
 548                                        E_MOVE_EVENT_PROPAGATE_TYPE_IMMEDIATELY);
 549 }
 550
 551 EINTERN E_Move_Border *
 552 e_mod_move_mini_apptray_find(void)
 553 {
 554    E_Move *m;
 555    E_Move_Border *mb;
 556
 557    m = e_mod_move_util_get();
 558    E_CHECK_RETURN(m, 0);
 559
 560    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 561      {
 562         if (TYPE_MINI_APPTRAY_CHECK(mb)) return mb;
 563      }
 564    return NULL;
 565 }
 566
 567 EINTERN Eina_Bool
 568 e_mod_move_mini_apptray_click_get(void)
 569 {
 570    E_Move_Border         *mb = NULL;
 571    Eina_Bool              click = EINA_FALSE;
 572    E_Move_Control_Object *mco = NULL;
 573    Eina_List             *l;
 574
 575    mb = e_mod_move_mini_apptray_find();
 576    E_CHECK_RETURN(mb, EINA_FALSE);
 577
 578    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 579      {
 580         if (!mco) continue;
 581         click = e_mod_move_event_click_get(mco->event);
 582      }
 583
 584    return click;
 585 }
 586
 587 EINTERN Eina_Bool
 588 e_mod_move_mini_apptray_event_clear(void)
 589 {
 590    E_Move_Border         *mb = NULL;
 591    Eina_Bool              click = EINA_FALSE;
 592    E_Move_Control_Object *mco = NULL;
 593    Eina_List             *l;
 594
 595    mb = e_mod_move_mini_apptray_find();
 596    E_CHECK_RETURN(mb, EINA_FALSE);
 597
 598    click = e_mod_move_mini_apptray_click_get();
 599    E_CHECK_RETURN(click, EINA_FALSE);
 600
 601    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 602      {
 603         if (!mco) continue;
 604         e_mod_move_event_data_clear(mco->event);
 605         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 606      }
 607
 608    if (mb->flick_data) e_mod_move_flick_data_free(mb);
 609
 610    return EINA_TRUE;
 611 }
 612
 613 EINTERN Eina_Bool
 614 e_mod_move_mini_apptray_objs_add(E_Move_Border *mb)
 615 {
 616    Eina_Bool mirror = EINA_TRUE;
 617    Evas_Object *ly = NULL;
 618    E_CHECK_RETURN(mb, EINA_FALSE);
 619    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 620
 621    ly = e_mod_move_util_comp_layer_get(mb->m, "move");
 622    E_CHECK_RETURN(ly, EINA_FALSE);
 623
 624    if (!(mb->objs))
 625      {
 626         // Composite mode set true
 627         e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_TRUE);
 628         mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
 629         e_mod_move_bd_move_objs_move(mb, mb->x, mb->y);
 630         e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
 631         e_mod_move_bd_move_objs_show(mb);
 632
 633         if (!evas_object_visible_get(ly))
 634           evas_object_show(ly);
 635
 636         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
 637      }
 638    return EINA_TRUE;
 639 }
 640
 641 EINTERN Eina_Bool
 642 e_mod_move_mini_apptray_objs_add_with_pos(E_Move_Border *mb,
 643                                           int            x,
 644                                           int            y)
 645 {
 646    Eina_Bool mirror = EINA_TRUE;
 647    E_CHECK_RETURN(mb, EINA_FALSE);
 648    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 649
 650    if (!(mb->objs))
 651      {
 652         mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
 653         e_mod_move_bd_move_objs_move(mb, x, y);
 654         e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
 655         e_mod_move_bd_move_objs_show(mb);
 656         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
 657      }
 658    return EINA_TRUE;
 659 }
 660
 661 EINTERN Eina_Bool
 662 e_mod_move_mini_apptray_objs_del(E_Move_Border *mb)
 663 {
 664    Evas_Object *ly = NULL;
 665    E_CHECK_RETURN(mb, EINA_FALSE);
 666    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 667    ly = e_mod_move_util_comp_layer_get(mb->m, "move");
 668    E_CHECK_RETURN(ly, EINA_FALSE);
 669    if (evas_object_visible_get(ly))
 670      evas_object_hide(ly);
 671    e_mod_move_bd_move_objs_del(mb, mb->objs);
 672    e_mod_move_util_rotation_unlock(mb->m);
 673    // Composite mode set False
 674    e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_FALSE);
 675    mb->objs = NULL;
 676    return EINA_TRUE;
 677 }
 678
 679 EINTERN Eina_Bool
 680 e_mod_move_mini_apptray_objs_move(E_Move_Border *mb,
 681                                   int            x,
 682                                   int            y)
 683 {
 684    E_CHECK_RETURN(mb, EINA_FALSE);
 685    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 686
 687    e_mod_move_bd_move_objs_move(mb, x, y);
 688    _e_mod_move_mini_apptray_objs_position_set(mb, x, y);
 689    _e_mod_move_mini_apptray_dim_objs_apply(mb, x, y);
 690    return EINA_TRUE;
 691 }
 692
 693 EINTERN Eina_Bool
 694 e_mod_move_mini_apptray_objs_raise(E_Move_Border *mb)
 695 {
 696    E_CHECK_RETURN(mb, EINA_FALSE);
 697    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 698    e_mod_move_bd_move_objs_raise(mb);
 699    return EINA_TRUE;
 700 }
 701
 702 EINTERN Eina_Bool
 703 e_mod_move_mini_apptray_objs_animation_move(E_Move_Border *mb,
 704                                             int            x,
 705                                             int            y)
 706 {
 707    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 708    Ecore_Animator *animator = NULL;
 709    int sx, sy; //start x, start y
 710    double anim_time = 0.0;
 711
 712    E_CHECK_RETURN(mb, EINA_FALSE);
 713    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 714    E_CHECK_RETURN(mb->m, EINA_FALSE);
 715    anim_time = mb->m->animation_duration;
 716
 717    if (e_mod_move_mini_apptray_objs_animation_state_get(mb))
 718      {
 719         e_mod_move_mini_apptray_objs_animation_stop(mb);
 720         e_mod_move_mini_apptray_objs_animation_clear(mb);
 721      }
 722
 723    anim_data = E_NEW(E_Move_Mini_Apptray_Animation_Data, 1);
 724    E_CHECK_RETURN(anim_data, EINA_FALSE);
 725
 726    if (_e_mod_move_mini_apptray_objs_position_get(mb, &sx, &sy))
 727      {
 728         anim_data->sx = sx;
 729         anim_data->sy = sy;
 730      }
 731    else
 732      {
 733         anim_data->sx = mb->x;
 734         anim_data->sy = mb->y;
 735         _e_mod_move_mini_apptray_objs_position_set(mb,
 736                                                    anim_data->sx,
 737                                                    anim_data->sy);
 738      }
 739
 740    anim_data->ex = x;
 741    anim_data->ey = y;
 742    anim_data->dx = anim_data->ex - anim_data->sx;
 743    anim_data->dy = anim_data->ey - anim_data->sy;
 744    animator = ecore_animator_timeline_add(anim_time,
 745                                           _e_mod_move_mini_apptray_objs_animation_frame,
 746                                           anim_data);
 747    if (!animator)
 748      {
 749         memset(anim_data, 0, sizeof(E_Move_Mini_Apptray_Animation_Data));
 750         E_FREE(anim_data);
 751         return EINA_FALSE;
 752      }
 753
 754    anim_data->animator = animator;
 755    anim_data->animating = EINA_TRUE;
 756    mb->anim_data = anim_data;
 757    return EINA_TRUE;
 758 }
 759
 760 EINTERN Eina_Bool
 761 e_mod_move_mini_apptray_objs_animation_state_get(E_Move_Border *mb)
 762 {
 763    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 764    E_CHECK_RETURN(mb, EINA_FALSE);
 765    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 766
 767    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 768    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 769    E_CHECK_RETURN(anim_data->animating, EINA_FALSE);
 770    return EINA_TRUE;
 771 }
 772
 773 EINTERN Eina_Bool
 774 e_mod_move_mini_apptray_objs_animation_stop(E_Move_Border *mb)
 775 {
 776    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 777    E_CHECK_RETURN(mb, EINA_FALSE);
 778    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 779
 780    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 781    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 782    ecore_animator_freeze(anim_data->animator);
 783    return EINA_TRUE;
 784 }
 785
 786 EINTERN Eina_Bool
 787 e_mod_move_mini_apptray_objs_animation_clear(E_Move_Border *mb)
 788 {
 789    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 790    E_CHECK_RETURN(mb, EINA_FALSE);
 791    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 792
 793    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 794    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 795    ecore_animator_del(anim_data->animator);
 796    memset(anim_data, 0, sizeof(E_Move_Mini_Apptray_Animation_Data));
 797    E_FREE(anim_data);
 798    mb->anim_data = NULL;
 799
 800    return EINA_TRUE;
 801 }
 802
 803 EINTERN void*
 804 e_mod_move_mini_apptray_internal_data_add(E_Move_Border *mb)
 805 {
 806    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 807    int dim_min = 0;
 808    E_CHECK_RETURN(mb, NULL);
 809    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), NULL);
 810    E_CHECK_RETURN(mb->m, NULL);
 811    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 812    dim_min = mb->m->dim_min_opacity;
 813    if (!mini_apptray_data)
 814      {
 815         mini_apptray_data = E_NEW(E_Move_Mini_Apptray_Data, 1);
 816         E_CHECK_RETURN(mini_apptray_data, NULL);
 817         mini_apptray_data->x = mb->x;
 818         mini_apptray_data->y = mb->y;
 819         mini_apptray_data->dim_objs = NULL;
 820         mini_apptray_data->opacity = dim_min;
 821         mb->data = mini_apptray_data;
 822      }
 823    return mb->data;
 824 }
 825
 826 EINTERN Eina_Bool
 827 e_mod_move_mini_apptray_internal_data_del(E_Move_Border *mb)
 828 {
 829    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 830    E_CHECK_RETURN(mb, EINA_FALSE);
 831    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 832    E_CHECK_RETURN(mb->data, EINA_FALSE);
 833    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 834    e_mod_move_mini_apptray_dim_hide(mb);
 835    E_FREE(mini_apptray_data);
 836    mb->data = NULL;
 837    e_mod_move_mini_apptray_widget_apply();// disable/destory mini_apptray_widget related datas
 838    return EINA_TRUE;
 839 }
 840
 841 EINTERN Eina_Bool
 842 e_mod_move_mini_apptray_e_border_move(E_Move_Border *mb,
 843                                       int            x,
 844                                       int            y)
 845 {
 846    E_Zone *zone;
 847
 848    E_CHECK_RETURN(mb, EINA_FALSE);
 849    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 850    E_CHECK_RETURN(mb->bd, EINA_FALSE);
 851
 852    zone = mb->bd->zone;
 853
 854    /* check whether zone contains border */
 855    if (E_CONTAINS(zone->x, zone->y,
 856                   zone->w, zone->h,
 857                   x, y, mb->w, mb->h))
 858      {
 859         e_border_focus_set(mb->bd, 1, 1);
 860      }
 861    else
 862      {
 863         e_border_focus_set(mb->bd, 0, 0);
 864      }
 865
 866    ELBF(ELBT_MOVE, 0, mb->bd->win,
 867         "MINI APP_TRAY MOVE w:0x%08x c:0x%08x [%d,%d]",
 868         mb->bd->win, mb->bd->client.win, x, y);
 869    e_border_move(mb->bd, x, y);
 870
 871    return EINA_TRUE;
 872 }
 873
 874 EINTERN Eina_Bool
 875 e_mod_move_mini_apptray_e_border_raise(E_Move_Border *mb)
 876 {
 877    E_CHECK_RETURN(mb, EINA_FALSE);
 878    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 879
 880    e_border_raise(mb->bd);
 881
 882    return EINA_TRUE;
 883 }
 884
 885 EINTERN Eina_Bool
 886 e_mod_move_mini_apptray_e_border_lower(E_Move_Border *mb)
 887 {
 888    E_CHECK_RETURN(mb, EINA_FALSE);
 889    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 890
 891    e_border_lower(mb->bd);
 892
 893    return EINA_TRUE;
 894 }
 895
 896 EINTERN Eina_List*
 897 e_mod_move_mini_apptray_dim_show(E_Move_Border *mb)
 898 {
 899    int dim_min = 0;
 900    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 901    E_CHECK_RETURN(mb, NULL);
 902    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), NULL);
 903    E_CHECK_RETURN(mb->m, NULL);
 904    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 905    dim_min = mb->m->dim_min_opacity;
 906    if (!mini_apptray_data)
 907      {
 908         mini_apptray_data = E_NEW(E_Move_Mini_Apptray_Data, 1);
 909         E_CHECK_RETURN(mini_apptray_data, NULL);
 910
 911         mini_apptray_data->x = mb->x;
 912         mini_apptray_data->y = mb->y;
 913         mini_apptray_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
 914         e_mod_move_bd_move_dim_objs_show(mini_apptray_data->dim_objs);
 915         mini_apptray_data->opacity = dim_min;
 916         mb->data = mini_apptray_data;
 917      }
 918    else
 919      {
 920         if (!(mini_apptray_data->dim_objs))
 921           {
 922              mini_apptray_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
 923           }
 924         if (mini_apptray_data->dim_objs)
 925           {
 926              e_mod_move_bd_move_dim_objs_show(mini_apptray_data->dim_objs);
 927              mini_apptray_data->opacity = dim_min;
 928           }
 929      }
 930
 931    L(LT_EVENT_OBJ,
 932      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
 933      "EVAS_OBJ", mb->bd->win, __func__);
 934
 935    return mini_apptray_data->dim_objs;
 936 }
 937
 938 EINTERN Eina_Bool
 939 e_mod_move_mini_apptray_dim_hide(E_Move_Border *mb)
 940 {
 941    int dim_min = 0;
 942    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 943    E_CHECK_RETURN(mb, EINA_FALSE);
 944    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 945    E_CHECK_RETURN(mb->m, EINA_FALSE);
 946    E_CHECK_RETURN(mb->data, EINA_FALSE);
 947    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 948    dim_min = mb->m->dim_min_opacity;
 949    E_CHECK_RETURN(mini_apptray_data->dim_objs, EINA_FALSE);
 950    e_mod_move_bd_move_dim_objs_hide(mini_apptray_data->dim_objs);
 951    e_mod_move_bd_move_dim_objs_del(mini_apptray_data->dim_objs);
 952    mini_apptray_data->dim_objs = NULL;
 953    mini_apptray_data->opacity = dim_min;
 954
 955    L(LT_EVENT_OBJ,
 956      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
 957      "EVAS_OBJ", ((mb->bd) ? mb->bd->win : NULL), __func__);
 958
 959    return EINA_TRUE;
 960 }
 961
 962 EINTERN Eina_Bool
 963 e_mod_move_mini_apptray_objs_animation_start_position_set(E_Move_Border *mb,
 964                                                           int            angle)
 965 {
 966    E_Zone *zone;
 967    int x, y;
 968    int cx, cy, cw, ch;
 969    Eina_Bool contents_region = EINA_FALSE;
 970
 971    E_CHECK_RETURN(mb, EINA_FALSE);
 972    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 973
 974    angle = ((angle % 360) / 90) * 90;
 975    zone = mb->bd->zone;
 976    contents_region = e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch);
 977
 978 // change later
 979 // todo flick-up position
 980    switch (angle)
 981      {
 982       case  90:
 983          if (contents_region) { x = zone->x + zone->w - cx; y = 0; }
 984          else                 { x = zone->x + zone->w;      y = 0; }
 985          break;
 986       case 180:
 987          if (contents_region) { x = 0; y = mb->h * -1 + (mb->h - ch); }
 988          else                 { x = 0; y = mb->h * -1;                }
 989          break;
 990       case 270:
 991          if (contents_region) { x = mb->w * -1 + (mb->w - cw); y = 0; }
 992          else                 { x = mb->w * -1;                y = 0; }
 993          break;
 994       case   0:
 995       default :
 996          if (contents_region) { x = 0; y = zone->y + zone->h - cy; }
 997          else                 { x = 0; y = zone->y + zone->h;      }
 998          break;
 999      }
1000
1001    _e_mod_move_mini_apptray_objs_position_set(mb, x, y);
1002
1003    return EINA_TRUE;
1004 }
1005
1006 EINTERN E_Move_Event_Cb
1007 e_mod_move_mini_apptray_event_cb_get(E_Move_Event_Type type)
1008 {
1009    if (type == E_MOVE_EVENT_TYPE_MOTION_START)
1010      return _e_mod_move_mini_apptray_cb_motion_start;
1011    else if (type == E_MOVE_EVENT_TYPE_MOTION_MOVE)
1012      return _e_mod_move_mini_apptray_cb_motion_move;
1013    else if (type == E_MOVE_EVENT_TYPE_MOTION_END)
1014      return _e_mod_move_mini_apptray_cb_motion_end;
1015    else
1016      return NULL;
1017 }
1018
1019 EINTERN Eina_Bool
1020 e_mod_move_mini_apptray_anim_state_send(E_Move_Border *mb,
1021                                         Eina_Bool state)
1022 {
1023    long d[5] = {0L, 0L, 0L, 0L, 0L};
1024    Ecore_X_Window win;
1025    E_CHECK_RETURN(mb, EINA_FALSE);
1026    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1027
1028    win = e_mod_move_util_client_xid_get(mb);
1029    E_CHECK_RETURN(win, 0);
1030
1031    if (state) d[0] = 1L;
1032    else d[0] = 0L;
1033
1034    ecore_x_client_message32_send
1035      (win, ATOM_MV_MINI_APPTRAY_STATE,
1036      ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
1037      d[0], d[1], d[2], d[3], d[4]);
1038
1039    return EINA_TRUE;
1040 }
1041
1042 EINTERN Eina_Bool
1043 e_mod_move_mini_apptray_objs_animation_layer_set(E_Move_Border *mb)
1044 {
1045    E_Move                  *m = e_mod_move_util_get();
1046    E_Move_Border           *find_mb = NULL;
1047    E_Move_Border           *state_above_mb = NULL;
1048    Ecore_X_Window           win;
1049    Eina_Bool                found = EINA_FALSE;
1050    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
1051
1052    E_CHECK_RETURN(m, EINA_FALSE);
1053    E_CHECK_RETURN(mb, EINA_FALSE);
1054    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1055
1056    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
1057    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
1058
1059    mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1060    mini_apptray_data->animation_layer_info.state_above.win = 0;
1061
1062    EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
1063      {
1064         if (find_mb->bd
1065             && (find_mb->bd->layer == e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER))
1066             && (find_mb->visible))
1067           {
1068              win = find_mb->bd->client.win;
1069              found = EINA_TRUE;
1070           }
1071
1072         if (find_mb->bd
1073             && (find_mb->bd->layer < e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER)))
1074           {
1075              break;
1076           }
1077      }
1078
1079    if (found)
1080      {
1081         mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_TRUE;
1082         mini_apptray_data->animation_layer_info.state_above.win = win;
1083         state_above_mb = e_mod_move_border_client_find(win);
1084         if (state_above_mb
1085             && !(state_above_mb->objs))
1086           {
1087              state_above_mb->objs = e_mod_move_bd_move_objs_add(state_above_mb, EINA_TRUE);
1088              e_mod_move_bd_move_objs_move(state_above_mb, state_above_mb->x, state_above_mb->y);
1089              e_mod_move_bd_move_objs_resize(state_above_mb, state_above_mb->w, state_above_mb->h);
1090              e_mod_move_bd_move_objs_show(state_above_mb);
1091           }
1092
1093         // mini_apptray mirror object stack below to state_above object .
1094         e_mod_move_bd_move_objs_stack_below(mb, state_above_mb); // mb : mini_apptray move border
1095      }
1096    else
1097      {
1098         e_mod_move_mini_apptray_objs_raise(mb);
1099      }
1100
1101    return EINA_TRUE;
1102 }
1103
1104 EINTERN Eina_Bool
1105 e_mod_move_mini_apptray_objs_animation_layer_unset(E_Move_Border *mb)
1106 {
1107    E_Move_Border            *state_above_mb = NULL;
1108    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
1109    Ecore_X_Window            win;
1110
1111    E_CHECK_RETURN(mb, EINA_FALSE);
1112    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1113
1114    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
1115    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
1116
1117    if (mini_apptray_data->animation_layer_info.state_above.layer_set)
1118      {
1119         win = mini_apptray_data->animation_layer_info.state_above.win;
1120         if ((state_above_mb = e_mod_move_border_client_find(win))
1121             && (!state_above_mb->animate_move))
1122           {
1123              e_mod_move_bd_move_objs_del(state_above_mb, state_above_mb->objs);
1124              state_above_mb->objs = NULL;
1125           }
1126      }
1127
1128    mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1129    mini_apptray_data->animation_layer_info.state_above.win = 0;
1130
1131    return EINA_TRUE;
1132 }