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         e_mod_move_util_screen_input_block(mb->m);
 633
 634         if (!evas_object_visible_get(ly))
 635           evas_object_show(ly);
 636
 637         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
 638      }
 639    return EINA_TRUE;
 640 }
 641
 642 EINTERN Eina_Bool
 643 e_mod_move_mini_apptray_objs_add_with_pos(E_Move_Border *mb,
 644                                           int            x,
 645                                           int            y)
 646 {
 647    Eina_Bool mirror = EINA_TRUE;
 648    E_CHECK_RETURN(mb, EINA_FALSE);
 649    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 650
 651    if (!(mb->objs))
 652      {
 653         mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
 654         e_mod_move_bd_move_objs_move(mb, x, y);
 655         e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
 656         e_mod_move_bd_move_objs_show(mb);
 657         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
 658      }
 659    return EINA_TRUE;
 660 }
 661
 662 EINTERN Eina_Bool
 663 e_mod_move_mini_apptray_objs_del(E_Move_Border *mb)
 664 {
 665    E_Move_Border *qp_mb = NULL;
 666    Evas_Object   *ly = NULL;
 667    E_CHECK_RETURN(mb, EINA_FALSE);
 668    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 669    ly = e_mod_move_util_comp_layer_get(mb->m, "move");
 670    E_CHECK_RETURN(ly, EINA_FALSE);
 671    if (evas_object_visible_get(ly))
 672      {
 673         qp_mb = e_mod_move_quickpanel_find();
 674         if (!e_mod_move_quickpanel_objs_animation_state_get(qp_mb))
 675           evas_object_hide(ly);
 676      }
 677    e_mod_move_bd_move_objs_del(mb, mb->objs);
 678    e_mod_move_util_rotation_unlock(mb->m);
 679    // Composite mode set False
 680    e_mod_move_util_compositor_composite_mode_set(mb->m, EINA_FALSE);
 681    e_mod_move_util_screen_input_unblock(mb->m);
 682    mb->objs = NULL;
 683    return EINA_TRUE;
 684 }
 685
 686 EINTERN Eina_Bool
 687 e_mod_move_mini_apptray_objs_move(E_Move_Border *mb,
 688                                   int            x,
 689                                   int            y)
 690 {
 691    E_CHECK_RETURN(mb, EINA_FALSE);
 692    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 693
 694    e_mod_move_bd_move_objs_move(mb, x, y);
 695    _e_mod_move_mini_apptray_objs_position_set(mb, x, y);
 696    _e_mod_move_mini_apptray_dim_objs_apply(mb, x, y);
 697    return EINA_TRUE;
 698 }
 699
 700 EINTERN Eina_Bool
 701 e_mod_move_mini_apptray_objs_raise(E_Move_Border *mb)
 702 {
 703    E_CHECK_RETURN(mb, EINA_FALSE);
 704    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 705    e_mod_move_bd_move_objs_raise(mb);
 706    return EINA_TRUE;
 707 }
 708
 709 EINTERN Eina_Bool
 710 e_mod_move_mini_apptray_objs_animation_move(E_Move_Border *mb,
 711                                             int            x,
 712                                             int            y)
 713 {
 714    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 715    Ecore_Animator *animator = NULL;
 716    int sx, sy; //start x, start y
 717    double anim_time = 0.0;
 718
 719    E_CHECK_RETURN(mb, EINA_FALSE);
 720    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 721    E_CHECK_RETURN(mb->m, EINA_FALSE);
 722    anim_time = mb->m->animation_duration;
 723
 724    if (e_mod_move_mini_apptray_objs_animation_state_get(mb))
 725      {
 726         e_mod_move_mini_apptray_objs_animation_stop(mb);
 727         e_mod_move_mini_apptray_objs_animation_clear(mb);
 728      }
 729
 730    anim_data = E_NEW(E_Move_Mini_Apptray_Animation_Data, 1);
 731    E_CHECK_RETURN(anim_data, EINA_FALSE);
 732
 733    if (_e_mod_move_mini_apptray_objs_position_get(mb, &sx, &sy))
 734      {
 735         anim_data->sx = sx;
 736         anim_data->sy = sy;
 737      }
 738    else
 739      {
 740         anim_data->sx = mb->x;
 741         anim_data->sy = mb->y;
 742         _e_mod_move_mini_apptray_objs_position_set(mb,
 743                                                    anim_data->sx,
 744                                                    anim_data->sy);
 745      }
 746
 747    anim_data->ex = x;
 748    anim_data->ey = y;
 749    anim_data->dx = anim_data->ex - anim_data->sx;
 750    anim_data->dy = anim_data->ey - anim_data->sy;
 751    animator = ecore_animator_timeline_add(anim_time,
 752                                           _e_mod_move_mini_apptray_objs_animation_frame,
 753                                           anim_data);
 754    if (!animator)
 755      {
 756         memset(anim_data, 0, sizeof(E_Move_Mini_Apptray_Animation_Data));
 757         E_FREE(anim_data);
 758         return EINA_FALSE;
 759      }
 760
 761    anim_data->animator = animator;
 762    anim_data->animating = EINA_TRUE;
 763    mb->anim_data = anim_data;
 764    return EINA_TRUE;
 765 }
 766
 767 EINTERN Eina_Bool
 768 e_mod_move_mini_apptray_objs_animation_state_get(E_Move_Border *mb)
 769 {
 770    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 771    E_CHECK_RETURN(mb, EINA_FALSE);
 772    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 773
 774    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 775    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 776    E_CHECK_RETURN(anim_data->animating, EINA_FALSE);
 777    return EINA_TRUE;
 778 }
 779
 780 EINTERN Eina_Bool
 781 e_mod_move_mini_apptray_objs_animation_stop(E_Move_Border *mb)
 782 {
 783    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 784    E_CHECK_RETURN(mb, EINA_FALSE);
 785    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 786
 787    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 788    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 789    ecore_animator_freeze(anim_data->animator);
 790    return EINA_TRUE;
 791 }
 792
 793 EINTERN Eina_Bool
 794 e_mod_move_mini_apptray_objs_animation_clear(E_Move_Border *mb)
 795 {
 796    E_Move_Mini_Apptray_Animation_Data *anim_data = NULL;
 797    E_CHECK_RETURN(mb, EINA_FALSE);
 798    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 799
 800    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
 801    anim_data = (E_Move_Mini_Apptray_Animation_Data *)mb->anim_data;
 802    ecore_animator_del(anim_data->animator);
 803    memset(anim_data, 0, sizeof(E_Move_Mini_Apptray_Animation_Data));
 804    E_FREE(anim_data);
 805    mb->anim_data = NULL;
 806
 807    return EINA_TRUE;
 808 }
 809
 810 EINTERN void*
 811 e_mod_move_mini_apptray_internal_data_add(E_Move_Border *mb)
 812 {
 813    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 814    int dim_min = 0;
 815    E_CHECK_RETURN(mb, NULL);
 816    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), NULL);
 817    E_CHECK_RETURN(mb->m, NULL);
 818    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 819    dim_min = mb->m->dim_min_opacity;
 820    if (!mini_apptray_data)
 821      {
 822         mini_apptray_data = E_NEW(E_Move_Mini_Apptray_Data, 1);
 823         E_CHECK_RETURN(mini_apptray_data, NULL);
 824         mini_apptray_data->x = mb->x;
 825         mini_apptray_data->y = mb->y;
 826         mini_apptray_data->dim_objs = NULL;
 827         mini_apptray_data->opacity = dim_min;
 828         mb->data = mini_apptray_data;
 829      }
 830    return mb->data;
 831 }
 832
 833 EINTERN Eina_Bool
 834 e_mod_move_mini_apptray_internal_data_del(E_Move_Border *mb)
 835 {
 836    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 837    E_CHECK_RETURN(mb, EINA_FALSE);
 838    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 839    E_CHECK_RETURN(mb->data, EINA_FALSE);
 840    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 841    e_mod_move_mini_apptray_dim_hide(mb);
 842    E_FREE(mini_apptray_data);
 843    mb->data = NULL;
 844    e_mod_move_mini_apptray_widget_apply();// disable/destory mini_apptray_widget related datas
 845    return EINA_TRUE;
 846 }
 847
 848 EINTERN Eina_Bool
 849 e_mod_move_mini_apptray_e_border_move(E_Move_Border *mb,
 850                                       int            x,
 851                                       int            y)
 852 {
 853    E_Zone *zone;
 854
 855    E_CHECK_RETURN(mb, EINA_FALSE);
 856    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 857    E_CHECK_RETURN(mb->bd, EINA_FALSE);
 858
 859    zone = mb->bd->zone;
 860
 861    /* check whether zone contains border */
 862    if (E_CONTAINS(zone->x, zone->y,
 863                   zone->w, zone->h,
 864                   x, y, mb->w, mb->h))
 865      {
 866         e_border_focus_set(mb->bd, 1, 1);
 867      }
 868    else
 869      {
 870         e_border_focus_set(mb->bd, 0, 0);
 871      }
 872
 873    ELBF(ELBT_MOVE, 0, mb->bd->win,
 874         "MINI APP_TRAY MOVE w:0x%08x c:0x%08x [%d,%d]",
 875         mb->bd->win, mb->bd->client.win, x, y);
 876    e_border_move(mb->bd, x, y);
 877
 878    return EINA_TRUE;
 879 }
 880
 881 EINTERN Eina_Bool
 882 e_mod_move_mini_apptray_e_border_raise(E_Move_Border *mb)
 883 {
 884    E_CHECK_RETURN(mb, EINA_FALSE);
 885    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 886
 887    e_border_raise(mb->bd);
 888
 889    return EINA_TRUE;
 890 }
 891
 892 EINTERN Eina_Bool
 893 e_mod_move_mini_apptray_e_border_lower(E_Move_Border *mb)
 894 {
 895    E_CHECK_RETURN(mb, EINA_FALSE);
 896    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 897
 898    e_border_lower(mb->bd);
 899
 900    return EINA_TRUE;
 901 }
 902
 903 EINTERN Eina_List*
 904 e_mod_move_mini_apptray_dim_show(E_Move_Border *mb)
 905 {
 906    int dim_min = 0;
 907    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 908    E_CHECK_RETURN(mb, NULL);
 909    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), NULL);
 910    E_CHECK_RETURN(mb->m, NULL);
 911    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 912    dim_min = mb->m->dim_min_opacity;
 913    if (!mini_apptray_data)
 914      {
 915         mini_apptray_data = E_NEW(E_Move_Mini_Apptray_Data, 1);
 916         E_CHECK_RETURN(mini_apptray_data, NULL);
 917
 918         mini_apptray_data->x = mb->x;
 919         mini_apptray_data->y = mb->y;
 920         mini_apptray_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
 921         e_mod_move_bd_move_dim_objs_show(mini_apptray_data->dim_objs);
 922         mini_apptray_data->opacity = dim_min;
 923         mb->data = mini_apptray_data;
 924      }
 925    else
 926      {
 927         if (!(mini_apptray_data->dim_objs))
 928           {
 929              mini_apptray_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
 930           }
 931         if (mini_apptray_data->dim_objs)
 932           {
 933              e_mod_move_bd_move_dim_objs_show(mini_apptray_data->dim_objs);
 934              mini_apptray_data->opacity = dim_min;
 935           }
 936      }
 937
 938    L(LT_EVENT_OBJ,
 939      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
 940      "EVAS_OBJ", mb->bd->win, __func__);
 941
 942    return mini_apptray_data->dim_objs;
 943 }
 944
 945 EINTERN Eina_Bool
 946 e_mod_move_mini_apptray_dim_hide(E_Move_Border *mb)
 947 {
 948    int dim_min = 0;
 949    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
 950    E_CHECK_RETURN(mb, EINA_FALSE);
 951    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 952    E_CHECK_RETURN(mb->m, EINA_FALSE);
 953    E_CHECK_RETURN(mb->data, EINA_FALSE);
 954    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
 955    dim_min = mb->m->dim_min_opacity;
 956    E_CHECK_RETURN(mini_apptray_data->dim_objs, EINA_FALSE);
 957    e_mod_move_bd_move_dim_objs_hide(mini_apptray_data->dim_objs);
 958    e_mod_move_bd_move_dim_objs_del(mini_apptray_data->dim_objs);
 959    mini_apptray_data->dim_objs = NULL;
 960    mini_apptray_data->opacity = dim_min;
 961
 962    L(LT_EVENT_OBJ,
 963      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
 964      "EVAS_OBJ", ((mb->bd) ? mb->bd->win : NULL), __func__);
 965
 966    return EINA_TRUE;
 967 }
 968
 969 EINTERN Eina_Bool
 970 e_mod_move_mini_apptray_objs_animation_start_position_set(E_Move_Border *mb,
 971                                                           int            angle)
 972 {
 973    E_Zone *zone;
 974    int x, y;
 975    int cx, cy, cw, ch;
 976    Eina_Bool contents_region = EINA_FALSE;
 977
 978    E_CHECK_RETURN(mb, EINA_FALSE);
 979    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
 980
 981    angle = ((angle % 360) / 90) * 90;
 982    zone = mb->bd->zone;
 983    contents_region = e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch);
 984
 985 // change later
 986 // todo flick-up position
 987    switch (angle)
 988      {
 989       case  90:
 990          if (contents_region) { x = zone->x + zone->w - cx; y = 0; }
 991          else                 { x = zone->x + zone->w;      y = 0; }
 992          break;
 993       case 180:
 994          if (contents_region) { x = 0; y = mb->h * -1 + (mb->h - ch); }
 995          else                 { x = 0; y = mb->h * -1;                }
 996          break;
 997       case 270:
 998          if (contents_region) { x = mb->w * -1 + (mb->w - cw); y = 0; }
 999          else                 { x = mb->w * -1;                y = 0; }
1000          break;
1001       case   0:
1002       default :
1003          if (contents_region) { x = 0; y = zone->y + zone->h - cy; }
1004          else                 { x = 0; y = zone->y + zone->h;      }
1005          break;
1006      }
1007
1008    _e_mod_move_mini_apptray_objs_position_set(mb, x, y);
1009
1010    return EINA_TRUE;
1011 }
1012
1013 EINTERN E_Move_Event_Cb
1014 e_mod_move_mini_apptray_event_cb_get(E_Move_Event_Type type)
1015 {
1016    if (type == E_MOVE_EVENT_TYPE_MOTION_START)
1017      return _e_mod_move_mini_apptray_cb_motion_start;
1018    else if (type == E_MOVE_EVENT_TYPE_MOTION_MOVE)
1019      return _e_mod_move_mini_apptray_cb_motion_move;
1020    else if (type == E_MOVE_EVENT_TYPE_MOTION_END)
1021      return _e_mod_move_mini_apptray_cb_motion_end;
1022    else
1023      return NULL;
1024 }
1025
1026 EINTERN Eina_Bool
1027 e_mod_move_mini_apptray_anim_state_send(E_Move_Border *mb,
1028                                         Eina_Bool state)
1029 {
1030    long d[5] = {0L, 0L, 0L, 0L, 0L};
1031    Ecore_X_Window win;
1032    E_CHECK_RETURN(mb, EINA_FALSE);
1033    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1034
1035    win = e_mod_move_util_client_xid_get(mb);
1036    E_CHECK_RETURN(win, 0);
1037
1038    if (state) d[0] = 1L;
1039    else d[0] = 0L;
1040
1041    ecore_x_client_message32_send
1042      (win, ATOM_MV_MINI_APPTRAY_STATE,
1043      ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
1044      d[0], d[1], d[2], d[3], d[4]);
1045
1046    return EINA_TRUE;
1047 }
1048
1049 EINTERN Eina_Bool
1050 e_mod_move_mini_apptray_objs_animation_layer_set(E_Move_Border *mb)
1051 {
1052    E_Move                  *m = e_mod_move_util_get();
1053    E_Move_Border           *find_mb = NULL;
1054    E_Move_Border           *state_above_mb = NULL;
1055    Ecore_X_Window           win;
1056    Eina_Bool                found = EINA_FALSE;
1057    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
1058
1059    E_CHECK_RETURN(m, EINA_FALSE);
1060    E_CHECK_RETURN(mb, EINA_FALSE);
1061    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1062
1063    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
1064    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
1065
1066    mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1067    mini_apptray_data->animation_layer_info.state_above.win = 0;
1068
1069    EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
1070      {
1071         if (find_mb->bd
1072             && (find_mb->bd->layer == e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER))
1073             && (find_mb->visible))
1074           {
1075              win = find_mb->bd->client.win;
1076              found = EINA_TRUE;
1077           }
1078
1079         if (find_mb->bd
1080             && (find_mb->bd->layer < e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER)))
1081           {
1082              break;
1083           }
1084      }
1085
1086    if (found)
1087      {
1088         mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_TRUE;
1089         mini_apptray_data->animation_layer_info.state_above.win = win;
1090         state_above_mb = e_mod_move_border_client_find(win);
1091         if (state_above_mb
1092             && !(state_above_mb->objs))
1093           {
1094              state_above_mb->objs = e_mod_move_bd_move_objs_add(state_above_mb, EINA_TRUE);
1095              e_mod_move_bd_move_objs_move(state_above_mb, state_above_mb->x, state_above_mb->y);
1096              e_mod_move_bd_move_objs_resize(state_above_mb, state_above_mb->w, state_above_mb->h);
1097              e_mod_move_bd_move_objs_show(state_above_mb);
1098           }
1099
1100         // mini_apptray mirror object stack below to state_above object .
1101         e_mod_move_bd_move_objs_stack_below(mb, state_above_mb); // mb : mini_apptray move border
1102      }
1103    else
1104      {
1105         e_mod_move_mini_apptray_objs_raise(mb);
1106      }
1107
1108    return EINA_TRUE;
1109 }
1110
1111 EINTERN Eina_Bool
1112 e_mod_move_mini_apptray_objs_animation_layer_unset(E_Move_Border *mb)
1113 {
1114    E_Move_Border            *state_above_mb = NULL;
1115    E_Move_Mini_Apptray_Data *mini_apptray_data = NULL;
1116    Ecore_X_Window            win;
1117
1118    E_CHECK_RETURN(mb, EINA_FALSE);
1119    E_CHECK_RETURN(TYPE_MINI_APPTRAY_CHECK(mb), EINA_FALSE);
1120
1121    mini_apptray_data = (E_Move_Mini_Apptray_Data *)mb->data;
1122    E_CHECK_RETURN(mini_apptray_data, EINA_FALSE);
1123
1124    if (mini_apptray_data->animation_layer_info.state_above.layer_set)
1125      {
1126         win = mini_apptray_data->animation_layer_info.state_above.win;
1127         if ((state_above_mb = e_mod_move_border_client_find(win))
1128             && (!state_above_mb->animate_move))
1129           {
1130              e_mod_move_bd_move_objs_del(state_above_mb, state_above_mb->objs);
1131              state_above_mb->objs = NULL;
1132           }
1133      }
1134
1135    mini_apptray_data->animation_layer_info.state_above.layer_set = EINA_FALSE;
1136    mini_apptray_data->animation_layer_info.state_above.win = 0;
1137
1138    return EINA_TRUE;
1139 }