move-tizen/src/e_mod_move_quickpanel.c

   1 #include "e_mod_move_shared_types.h"
   2 #include "e_mod_move_debug.h"
   3 #include "e_mod_move.h"
   4 #include "e_mod_move_atoms.h"
   5
   6 struct _E_Move_Quickpanel_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_quickpanel_cb_motion_start(void *data, void *event_info);
  20 static Eina_Bool          _e_mod_move_quickpanel_cb_motion_move(void *data, void *event_info);
  21 static Eina_Bool          _e_mod_move_quickpanel_cb_motion_end(void *data, void *event_info);
  22 static Eina_Bool          _e_mod_move_quickpanel_objs_position_set(E_Move_Border *mb, int x, int y);
  23 static Eina_Bool          _e_mod_move_quickpanel_objs_position_get(E_Move_Border *mb, int *x, int *y);
  24 static Eina_Bool          _e_mod_move_quickpanel_objs_moving_distance_rate_get(E_Move_Border *mb, int angle, double *rate);
  25 static Eina_Bool          _e_mod_move_quickpanel_objs_animation_frame(void  *data, double pos);
  26 static Eina_Bool          _e_mod_move_quickpanel_flick_process(E_Move_Border *mb, int angle, Eina_Bool state);
  27 static Eina_Bool          _e_mod_move_quickpanel_dim_objs_apply(E_Move_Border *mb, int x, int y);
  28 static Eina_Bool          _e_mod_move_quickpanel_below_window_set(void);
  29 static void               _e_mod_move_quickpanel_below_window_unset(void);
  30 static Eina_Bool          _e_mod_move_quickpanel_below_window_objs_add(void);
  31 static Eina_Bool          _e_mod_move_quickpanel_below_window_objs_del(void);
  32 static Eina_Bool          _e_mod_move_quickpanel_below_window_objs_move(int x, int y);
  33 static Eina_Bool          _e_mod_move_quickpanel_handle_objs_add(E_Move_Border *mb);
  34 static Eina_Bool          _e_mod_move_quickpanel_handle_objs_del(E_Move_Border *mb);
  35 static Eina_Bool          _e_mod_move_quickpanel_handle_objs_size_update(E_Move_Border *mb, int w, int h);
  36 static Eina_Bool          _e_mod_move_quickpanel_handle_objs_move(E_Move_Border *mb, int x, int y);
  37 static Eina_Bool          _e_mod_move_quickpanel_objs_check_on_screen(E_Move_Border *mb, int x, int y);
  38 static Eina_Bool          _e_mod_move_quickpanel_objs_outside_movable_pos_get(E_Move_Border *mb, int *x, int *y);
  39 static Eina_Bool          _e_mod_move_quickpanel_animation_change_with_angle(E_Move_Border *mb);
  40 static Eina_Bool          _e_mod_move_quickpanel_fb_move_change_with_angle(E_Move_Border *mb);
  41 static Eina_Bool          _e_mod_move_quickpanel_comp_layer_obj_move(int x, int y);
  42 static Eina_Bool          _e_mod_move_quickpanel_comp_layer_obj_move_intern(int x, int y);
  43
  44 /* local subsystem functions */
  45 static Eina_Bool
  46 _e_mod_move_quickpanel_cb_motion_start(void *data,
  47                                        void *event_info)
  48 {
  49    E_Move_Border *mb = (E_Move_Border *)data;
  50    E_Move_Event_Motion_Info *info;
  51    E_Move_Control_Object *mco = NULL;
  52    Evas_Event_Mouse_Down *mouse_down_event = NULL;
  53    Eina_Bool clicked = EINA_FALSE;
  54    Eina_List *l;
  55    int angle = 0;
  56
  57    info  = (E_Move_Event_Motion_Info *)event_info;
  58    if (!mb || !info) return EINA_FALSE;
  59
  60    mouse_down_event = info->event_info;
  61    E_CHECK_RETURN(mouse_down_event, EINA_FALSE);
  62    if (mouse_down_event->button != 1)
  63      return EINA_FALSE;
  64
  65    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  66      {
  67         if (!mco) continue;
  68         clicked = e_mod_move_event_click_get(mco->event);
  69      }
  70    if (clicked)
  71      return EINA_FALSE;
  72
  73    SL(LT_EVENT_OBJ,
  74       "[MOVE] ev:%15.15s w:0x%08x %s()\n", "EVAS_OBJ", mb->bd->win, __func__);
  75
  76    if (e_mod_move_quickpanel_objs_animation_state_get(mb)) goto error_cleanup;
  77
  78    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  79      {
  80         if (!mco) continue;
  81         angle = e_mod_move_event_angle_get(mco->event);
  82      }
  83    mb->angle = angle;
  84
  85    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
  86      {
  87         if (!mco) continue;
  88         e_mod_move_event_click_set(mco->event, EINA_TRUE);
  89      }
  90
  91    E_CHECK_GOTO(mb->visible, error_cleanup);
  92    if (!(REGION_INTERSECTS_WITH_ZONE(mb, mb->bd->zone)))
  93       goto error_cleanup;
  94
  95    E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
  96    e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
  97
  98    e_mod_move_quickpanel_objs_add(mb);
  99
 100    // send quickpanel to "move start message".
 101    e_mod_move_quickpanel_anim_state_send(mb, EINA_TRUE);
 102
 103    return EINA_TRUE;
 104
 105 error_cleanup:
 106
 107    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 108      {
 109         if (!mco) continue;
 110         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 111      }
 112    return EINA_FALSE;
 113 }
 114
 115 static Eina_Bool
 116 _e_mod_move_quickpanel_cb_motion_move(void *data,
 117                                       void *event_info)
 118 {
 119    E_Move *m = NULL;
 120    E_Move_Border *mb = (E_Move_Border *)data;
 121    E_Move_Event_Motion_Info *info;
 122    E_Move_Control_Object *mco = NULL;
 123    Eina_List *l;
 124    int angle = 0;
 125    E_Zone *zone = NULL;
 126    Eina_Bool click = EINA_FALSE;
 127    int cx, cy, cw, ch;
 128
 129    info  = (E_Move_Event_Motion_Info *)event_info;
 130    if (!mb || !info) return EINA_FALSE;
 131
 132    SL(LT_EVENT_OBJ,
 133       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 134       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 135       __func__);
 136
 137    m = mb->m;
 138    angle = mb->angle;
 139    zone = mb->bd->zone;
 140
 141    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 142      {
 143         if (!mco) continue;
 144         click = e_mod_move_event_click_get(mco->event);
 145      }
 146    E_CHECK_RETURN(click, EINA_FALSE);
 147
 148    if (m->qp_scroll_with_clipping)
 149      e_mod_move_quickpanel_objs_move(mb, info->coord.x, info->coord.y);
 150    else
 151      {
 152         switch (angle)
 153           {
 154            case   0:
 155               if (info->coord.y < mb->h)
 156                 {
 157                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 158                      {
 159                         if (info->coord.y < ch)
 160                           {
 161                              e_mod_move_quickpanel_objs_move(mb, 0,
 162                                                              info->coord.y - ch);
 163                           }
 164                      }
 165                    else
 166                      {
 167                         e_mod_move_quickpanel_objs_move(mb, 0,
 168                                                         info->coord.y - mb->h);
 169                      }
 170                 }
 171               break;
 172            case  90:
 173               if (info->coord.x < mb->w)
 174                 {
 175                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 176                      {
 177                         if (info->coord.x < cw)
 178                           {
 179                              e_mod_move_quickpanel_objs_move(mb, info->coord.x - cw,
 180                                                              0);
 181                           }
 182                      }
 183                    else
 184                      {
 185                         e_mod_move_quickpanel_objs_move(mb, info->coord.x - mb->w,
 186                                                         0);
 187                      }
 188                 }
 189               break;
 190            case 180:
 191               if (info->coord.y > (zone->h - mb->h))
 192                 {
 193                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 194                      {
 195                         if (info->coord.y > cy)
 196                           {
 197                              e_mod_move_quickpanel_objs_move(mb, 0,
 198                                                              info->coord.y - cy);
 199                           }
 200                      }
 201                    else
 202                      {
 203                         e_mod_move_quickpanel_objs_move(mb, 0, info->coord.y);
 204                      }
 205                 }
 206               break;
 207            case 270:
 208               if (info->coord.x > (zone->w - mb->w))
 209                 {
 210                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 211                      {
 212                         if (info->coord.x > cx)
 213                           {
 214                              e_mod_move_quickpanel_objs_move(mb,
 215                                                              info->coord.x - cx,
 216                                                              0);
 217                           }
 218                      }
 219                    else
 220                      {
 221                         e_mod_move_quickpanel_objs_move(mb, info->coord.x, 0);
 222                      }
 223                 }
 224               break;
 225            default :
 226               break;
 227           }
 228      }
 229
 230    return EINA_TRUE;
 231 }
 232
 233 static Eina_Bool
 234 _e_mod_move_quickpanel_cb_motion_end(void *data,
 235                                      void *event_info)
 236 {
 237    E_Move *m = NULL;
 238    E_Move_Border *mb = (E_Move_Border *)data;
 239    E_Move_Event_Motion_Info *info;
 240    E_Move_Control_Object *mco = NULL;
 241    Evas_Event_Mouse_Up *mouse_up_event;
 242    Eina_List *l;
 243    int angle = 0;
 244    E_Zone *zone = NULL;
 245    Eina_Bool click = EINA_FALSE;
 246    Eina_Bool flick_state = EINA_FALSE;
 247    int cx, cy, cw, ch;
 248    int check_w, check_h;
 249
 250    info  = (E_Move_Event_Motion_Info *)event_info;
 251    if (!mb || !info) return EINA_FALSE;
 252
 253    mouse_up_event = info->event_info;
 254
 255    E_CHECK_RETURN(mouse_up_event, EINA_FALSE);
 256    if (mouse_up_event->button != 1)
 257      return EINA_FALSE;
 258
 259    SL(LT_EVENT_OBJ,
 260       "[MOVE] ev:%15.15s w:0x%08x ,angle:%d, (%d,%d)  %s()\n",
 261       "EVAS_OBJ", mb->bd->win, mb->angle, info->coord.x, info->coord.y,
 262       __func__);
 263
 264    m = mb->m;
 265    angle = mb->angle;
 266    zone = mb->bd->zone;
 267
 268    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 269      {
 270         if (!mco) continue;
 271         click = e_mod_move_event_click_get(mco->event);
 272      }
 273    E_CHECK_GOTO(click, finish);
 274
 275    e_mod_move_flick_data_update(mb, info->coord.x, info->coord.y);
 276    flick_state = e_mod_move_flick_state_get(mb, EINA_FALSE);
 277    if (_e_mod_move_quickpanel_flick_process(mb, angle, flick_state))
 278      {
 279         return EINA_TRUE;
 280      }
 281
 282    switch (angle)
 283      {
 284       case   0:
 285          check_h = mb->h;
 286          if (check_h) check_h /= 2;
 287          if (info->coord.y < check_h)
 288            {
 289               if (m->qp_scroll_with_clipping)
 290                 {
 291                    e_mod_move_quickpanel_e_border_move(mb, 0, mb->h * -1);
 292                    e_mod_move_quickpanel_objs_animation_move(mb, zone->x, zone->y);
 293                 }
 294               else
 295                 {
 296                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 297                      {
 298                         check_h = ch;
 299                         if (check_h) check_h /= 2;
 300                         if (info->coord.y < check_h)
 301                           {
 302                              e_mod_move_quickpanel_e_border_move(mb, 0, mb->h * -1);
 303                              e_mod_move_quickpanel_objs_animation_move(mb, 0, ch * -1);
 304                           }
 305                         else
 306                           {
 307                              e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 308                           }
 309                      }
 310                 }
 311            }
 312          else
 313            {
 314               if (m->qp_scroll_with_clipping)
 315                 {
 316                    e_mod_move_quickpanel_objs_animation_move(mb,
 317                                                              zone->x + mb->w,
 318                                                              zone->y + mb->h);
 319                 }
 320               else
 321                 {
 322                    e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 323                 }
 324            }
 325          break;
 326       case  90:
 327          check_w = mb->w;
 328          if (check_w) check_w /= 2;
 329          if (info->coord.x < check_w)
 330            {
 331               if (m->qp_scroll_with_clipping)
 332                 {
 333                    e_mod_move_quickpanel_e_border_move(mb, mb->w * -1, 0);
 334                    e_mod_move_quickpanel_objs_animation_move(mb, zone->x, zone->y);
 335                 }
 336               else
 337                 {
 338                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 339                      {
 340                         check_w = cw;
 341                         if (check_w) check_w /= 2;
 342                         if (info->coord.x < check_w)
 343                           {
 344                              e_mod_move_quickpanel_e_border_move(mb, mb->w * -1, 0);
 345                              e_mod_move_quickpanel_objs_animation_move(mb, cw * -1, 0);
 346                           }
 347                         else
 348                           {
 349                              e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 350                           }
 351                      }
 352                 }
 353            }
 354          else
 355            {
 356               if (m->qp_scroll_with_clipping)
 357                 {
 358                    e_mod_move_quickpanel_objs_animation_move(mb,
 359                                                              zone->x + mb->w,
 360                                                              zone->y + mb->h);
 361                 }
 362               else
 363                 {
 364                    e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 365                 }
 366            }
 367          break;
 368       case 180:
 369          check_h = mb->h;
 370          if (check_h) check_h /= 2;
 371          if (info->coord.y > (zone->h - check_h))
 372            {
 373               if (m->qp_scroll_with_clipping)
 374                 {
 375                    e_mod_move_quickpanel_e_border_move(mb, 0, zone->h);
 376                    e_mod_move_quickpanel_objs_animation_move(mb,
 377                                                              zone->x + mb->w,
 378                                                              zone->y + mb->h);
 379                 }
 380               else
 381                 {
 382                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 383                      {
 384                         check_h = ch;
 385                         if (check_h) check_h /= 2;
 386                         if (info->coord.y > (cy + check_h))
 387                           {
 388                              e_mod_move_quickpanel_e_border_move(mb, 0, zone->h);
 389                              e_mod_move_quickpanel_objs_animation_move(mb, 0, ch);
 390                           }
 391                         else
 392                           {
 393                              e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 394                           }
 395                      }
 396                 }
 397            }
 398          else
 399            {
 400               e_mod_move_quickpanel_e_border_move(mb, 0, 0);
 401               if (m->qp_scroll_with_clipping)
 402                 {
 403                    e_mod_move_quickpanel_objs_animation_move(mb,
 404                                                              zone->x,
 405                                                              zone->y);
 406                 }
 407               else
 408                 {
 409                    e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 410                 }
 411            }
 412          break;
 413       case 270:
 414          check_w = mb->w;
 415          if (check_w) check_w /= 2;
 416          if (info->coord.x > (zone->w - check_w))
 417            {
 418               if (m->qp_scroll_with_clipping)
 419                 {
 420                    e_mod_move_quickpanel_e_border_move(mb, zone->w, 0);
 421                    e_mod_move_quickpanel_objs_animation_move(mb,
 422                                                              zone->x + mb->w,
 423                                                              zone->y + mb->h);
 424                 }
 425               else
 426                 {
 427                    if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 428                      {
 429                         check_w = cw;
 430                         if (check_w) check_w /= 2;
 431                         if (info->coord.x > (cx + check_w))
 432                           {
 433                              e_mod_move_quickpanel_e_border_move(mb, zone->w, 0);
 434                              e_mod_move_quickpanel_objs_animation_move(mb, cw, 0);
 435                           }
 436                         else
 437                           {
 438                              e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 439                           }
 440                      }
 441                 }
 442            }
 443          else
 444            {
 445               e_mod_move_quickpanel_e_border_move(mb, 0, 0);
 446               if (m->qp_scroll_with_clipping)
 447                 {
 448                    e_mod_move_quickpanel_objs_animation_move(mb, zone->x, zone->y);
 449                 }
 450               else
 451                 {
 452                    e_mod_move_quickpanel_objs_animation_move(mb, 0, 0);
 453                 }
 454            }
 455          break;
 456       default :
 457          break;
 458      }
 459
 460    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
 461      {
 462         if (!mco) continue;
 463         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 464      }
 465
 466 finish:
 467    if (mb->flick_data) e_mod_move_flick_data_free(mb);
 468    return EINA_TRUE;
 469 }
 470
 471 static Eina_Bool
 472 _e_mod_move_quickpanel_objs_position_set(E_Move_Border *mb,
 473                                          int            x,
 474                                          int            y)
 475 {
 476    E_Move_Quickpanel_Data *qp_data = NULL;
 477    E_CHECK_RETURN(mb, EINA_FALSE);
 478    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
 479    qp_data = (E_Move_Quickpanel_Data *)mb->data;
 480    if (!qp_data)
 481      qp_data = (E_Move_Quickpanel_Data *)e_mod_move_quickpanel_internal_data_add(mb);
 482    E_CHECK_RETURN(qp_data, EINA_FALSE);
 483    qp_data->x = x; qp_data->y = y;
 484    mb->data = qp_data;
 485    return EINA_TRUE;
 486 }
 487
 488 static Eina_Bool
 489 _e_mod_move_quickpanel_objs_position_get(E_Move_Border *mb,
 490                                          int           *x,
 491                                          int           *y)
 492 {
 493    E_Move_Quickpanel_Data *qp_data = NULL;
 494    E_CHECK_RETURN(mb, EINA_FALSE);
 495    E_CHECK_RETURN(x, EINA_FALSE);
 496    E_CHECK_RETURN(y, EINA_FALSE);
 497    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
 498    qp_data = (E_Move_Quickpanel_Data *)mb->data;
 499    E_CHECK_RETURN(qp_data, EINA_FALSE);
 500    *x = qp_data->x; *y = qp_data->y;
 501    return EINA_TRUE;
 502 }
 503
 504 static Eina_Bool
 505 _e_mod_move_quickpanel_objs_moving_distance_rate_get(E_Move_Border *mb,
 506                                                      int            angle,
 507                                                      double        *rate)
 508 {
 509    E_Move *m = NULL;
 510    E_Border *bd = NULL;
 511    E_Zone *zone = NULL;
 512    E_Move_Quickpanel_Data *qp_data = NULL;
 513    int x = 0, y = 0;
 514    int cx = 0, cy = 0, cw = 0, ch = 0;
 515    double dist_rate = 0.0;
 516
 517    E_CHECK_RETURN(mb, EINA_FALSE);
 518    E_CHECK_RETURN(rate, EINA_FALSE);
 519    m = mb->m;
 520    E_CHECK_RETURN(m, EINA_FALSE);
 521    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
 522    qp_data = (E_Move_Quickpanel_Data *)mb->data;
 523    E_CHECK_RETURN(qp_data, EINA_FALSE);
 524    bd = mb->bd;
 525    E_CHECK_RETURN(bd, EINA_FALSE);
 526    zone = bd->zone;
 527    E_CHECK_RETURN(zone, EINA_FALSE);
 528
 529    if (!_e_mod_move_quickpanel_objs_position_get(mb, &x, &y))
 530      return EINA_FALSE;
 531
 532    switch (angle)
 533      {
 534       case   0:
 535          if (m->qp_scroll_with_clipping)
 536            dist_rate = (double)y / (zone->y + zone->h);
 537          else
 538            {
 539               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 540                 dist_rate = (double)(y + ch) / (zone->y + zone->h);
 541               else
 542                 dist_rate = (double)(y + mb->h) / (zone->y + zone->h);
 543            }
 544          break;
 545       case  90:
 546          if (m->qp_scroll_with_clipping)
 547            dist_rate = (double)x / (zone->x + zone->w);
 548          else
 549            {
 550               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 551                 dist_rate = (double)(x + cw) / (zone->x + zone->w);
 552               else
 553                 dist_rate = (double)(x + mb->w) / (zone->x + zone->w);
 554            }
 555          break;
 556       case 180:
 557          if (m->qp_scroll_with_clipping)
 558            dist_rate = 1.0 - ((double)y / (zone->y + zone->h));
 559          else
 560            {
 561               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 562                 dist_rate = 1.0 - ((double)(y + cy) / (zone->y + zone->h));
 563               else
 564                 dist_rate = 1.0 - ((double)y / (zone->y + zone->h));
 565            }
 566          break;
 567       case 270:
 568          if (m->qp_scroll_with_clipping)
 569            dist_rate = 1.0 - ((double)x / (zone->x + zone->w));
 570          else
 571            {
 572               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 573                 dist_rate = 1.0 - ((double)(x + cx) / (zone->x + zone->w));
 574               else
 575                 dist_rate = 1.0 - ((double)x / (zone->x + zone->w));
 576            }
 577          break;
 578       default :
 579          return EINA_FALSE;
 580          break;
 581      }
 582
 583    *rate = dist_rate;
 584
 585    return EINA_TRUE;
 586 }
 587
 588 static Eina_Bool
 589 _e_mod_move_quickpanel_objs_animation_frame(void  *data,
 590                                             double pos)
 591 {
 592    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
 593    E_Move_Border                    *mb = NULL;
 594    E_Move_Border                    *find_mb = NULL;
 595    E_Border                         *bd = NULL;
 596    E_Zone                           *zone = NULL;
 597    double                            frame = pos;
 598    int                               x, y;
 599    Ecore_X_Window                    win;
 600    E_Move                           *m = NULL;
 601    Eina_Bool                         mv_ret = EINA_FALSE;
 602
 603    anim_data = (E_Move_Quickpanel_Animation_Data *)data;
 604    E_CHECK_RETURN(anim_data, EINA_FALSE);
 605
 606    mb = e_mod_move_quickpanel_find();
 607    E_CHECK_RETURN(mb, EINA_FALSE);
 608    m = mb->m;
 609
 610    frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE, 0.0, 0.0);
 611    x = anim_data->sx + anim_data->dx * frame;
 612    y = anim_data->sy + anim_data->dy * frame;
 613
 614    // When Animation is ended, if new window is added or window stack changed, then apply new info
 615    if (pos >= 1.0
 616        && m->qp_scroll_with_clipping)
 617      e_mod_move_quickpanel_below_window_reset();
 618
 619    e_mod_move_quickpanel_objs_move(mb, x, y);
 620
 621    if (pos >= 1.0)
 622      {
 623          bd = mb->bd;
 624          zone = bd->zone;
 625          mv_ret = e_mod_move_quickpanel_objs_move(mb, anim_data->ex, anim_data->ey);
 626
 627          if (!mv_ret) // objs move fail case
 628            {
 629               // while quickpanel is animating, if quickpanel angle changed, qp_objs move could fail. so qp_objs move again with changed angle.
 630               if (!E_INTERSECTS(bd->x, bd->y, bd->w, bd->h,
 631                                 zone->x, zone->y, zone->w, zone->h))
 632                 {
 633                    if (_e_mod_move_quickpanel_objs_outside_movable_pos_get(mb,
 634                                                                            &x,
 635                                                                            &y))
 636                      e_mod_move_quickpanel_objs_move(mb, x, y);
 637                 }
 638            }
 639
 640          // send quickpanel to "move end message".
 641          e_mod_move_quickpanel_anim_state_send(mb, EINA_FALSE);
 642
 643          e_mod_move_quickpanel_objs_del(mb);
 644          if (!E_INTERSECTS(bd->x, bd->y, bd->w, bd->h,
 645                            zone->x, zone->y, zone->w, zone->h)) // it work when quickpanel is not equal to zone size
 646            {
 647               win = e_mod_move_util_client_xid_get(mb);
 648
 649               EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
 650                 {
 651                    if (find_mb->visible)
 652                      {
 653                         if (find_mb->bd)
 654                            ecore_x_e_illume_quickpanel_state_send(find_mb->bd->client.win,
 655                                                                   ECORE_X_ILLUME_QUICKPANEL_STATE_OFF);
 656                      }
 657                    else
 658                      {
 659                         if (find_mb->bd && find_mb->bd->iconic)
 660                            ecore_x_e_illume_quickpanel_state_send(find_mb->bd->client.win,
 661                                                                   ECORE_X_ILLUME_QUICKPANEL_STATE_OFF);
 662                      }
 663                 }
 664
 665               if (!m->qp_scroll_with_clipping)
 666                 {
 667                    // if dim use case, hold below windows until dim  is on screen
 668                    // dim hide calls deletion of below window mirror object
 669                    e_mod_move_quickpanel_dim_hide(mb);
 670                 }
 671               // Set No Composite Mode & Rotation UnLock & Destroy below win's mirror object
 672               e_mod_move_quickpanel_stage_deinit(mb);
 673
 674               ecore_x_e_illume_quickpanel_state_set(zone->black_win, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF);
 675            }
 676
 677          // restore comp layer's position
 678          _e_mod_move_quickpanel_comp_layer_obj_move_intern(zone->x, zone->y);
 679
 680          memset(anim_data, 0, sizeof(E_Move_Quickpanel_Animation_Data));
 681          E_FREE(anim_data);
 682          mb->anim_data = NULL;
 683      }
 684    return EINA_TRUE;
 685 }
 686
 687 static Eina_Bool
 688 _e_mod_move_quickpanel_flick_process(E_Move_Border *mb,
 689                                      int            angle,
 690                                      Eina_Bool      state)
 691 {
 692    E_Move *m = NULL;
 693    E_Move_Control_Object *mco = NULL;
 694    Eina_List *l;
 695    int mx = 0, my = 0, ax = 0, ay = 0;
 696    E_Zone *zone = NULL;
 697    E_CHECK_RETURN(mb, EINA_FALSE);
 698    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
 699    E_CHECK_RETURN(state, EINA_FALSE);
 700
 701    m = mb->m;
 702    zone = mb->bd->zone;
 703
 704    EINA_LIST_FOREACH(mb->ctl_objs, l, mco) // apptray click unset
 705      {
 706         if (!mco) continue;
 707         e_mod_move_event_click_set(mco->event, EINA_FALSE);
 708      }
 709
 710    e_mod_move_flick_data_free(mb);
 711
 712    switch (angle)
 713      {
 714       case  90:
 715          mx = mb->w * -1; my = 0;
 716          if (m->qp_scroll_with_clipping)
 717            {
 718               ax = zone->x; ay = zone->y;
 719            }
 720          else
 721            {
 722               ax = mx; ay = my;
 723            }
 724          break;
 725       case 180:
 726          mx = 0; my = zone->h;
 727          if (m->qp_scroll_with_clipping)
 728            {
 729               ax = zone->x + mb->w;
 730               ay = zone->y + mb->h;
 731            }
 732          else
 733            {
 734               ax = mx; ay = my;
 735            }
 736          break;
 737       case 270:
 738          mx = zone->w; my = 0;
 739          if (m->qp_scroll_with_clipping)
 740            {
 741               ax = zone->x + mb->w;
 742               ay = zone->y + mb->h;
 743            }
 744          else
 745            {
 746               ax = mx; ay = my;
 747            }
 748          break;
 749       case   0:
 750       default :
 751          mx = 0; my = mb->h * -1;
 752          if (m->qp_scroll_with_clipping)
 753            {
 754               ax = zone->x; ay = zone->y;
 755            }
 756          else
 757            {
 758               ax = mx; ay = my;
 759            }
 760          break;
 761      }
 762
 763    e_mod_move_quickpanel_e_border_move(mb, mx, my);
 764    e_mod_move_quickpanel_objs_animation_move(mb, ax, ay);
 765
 766    return EINA_TRUE;
 767 }
 768
 769 static Eina_Bool
 770 _e_mod_move_quickpanel_dim_objs_apply(E_Move_Border *mb,
 771                                       int            x,
 772                                       int            y)
 773 {
 774    int angle;
 775    int mx, my;
 776    int opacity;
 777    int dim_max;
 778    E_Zone *zone = NULL;
 779    E_Move_Quickpanel_Data *qp_data = NULL;
 780    int cx, cy, cw, ch;
 781
 782    E_CHECK_RETURN(mb, EINA_FALSE);
 783    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
 784    E_CHECK_RETURN(mb->data, EINA_FALSE);
 785
 786    qp_data = (E_Move_Quickpanel_Data *)mb->data;
 787    E_CHECK_RETURN(qp_data->dim_objs, EINA_FALSE);
 788
 789    angle = mb->angle;
 790    zone = mb->bd->zone;
 791    dim_max = mb->m->dim_max_opacity;
 792
 793    switch (angle)
 794      {
 795       case  90:
 796          if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 797            {
 798               mx = x + cw;
 799               if (cw)
 800                 opacity = dim_max * mx / cw;
 801               else
 802                 opacity = dim_max;
 803            }
 804          else
 805            {
 806               mx = x + mb->w;
 807               if (mb->w)
 808                 opacity = dim_max * mx / mb->w;
 809               else
 810                 opacity = dim_max;
 811            }
 812          break;
 813       case 180:
 814          if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 815            {
 816               my = zone->h - (cy + y);
 817               if (ch)
 818                 opacity = dim_max * my / ch;
 819               else
 820                 opacity = dim_max;
 821            }
 822          else
 823            {
 824               my = zone->h - y;
 825               if (zone->h)
 826                 opacity = dim_max * my / zone->h;
 827               else
 828                 opacity = dim_max;
 829            }
 830          break;
 831       case 270:
 832          if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 833            {
 834               mx = zone->w - (cx + x);
 835               if (cw)
 836                 opacity = dim_max * mx / cw;
 837               else
 838                 opacity = dim_max;
 839            }
 840          else
 841            {
 842               mx = zone->w - x;
 843               if (zone->w)
 844                 opacity = dim_max * mx / zone->w;
 845               else
 846                 opacity = dim_max;
 847            }
 848          break;
 849       case   0:
 850       default :
 851          if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
 852            {
 853               my = y + ch;
 854               if (ch)
 855                 opacity = dim_max * my / ch;
 856               else
 857                 opacity = dim_max;
 858            }
 859          else
 860            {
 861               my = y + mb->h;
 862               if (mb->h)
 863                 opacity = dim_max * my / mb->h;
 864               else
 865                 opacity = dim_max;
 866            }
 867          break;
 868      }
 869
 870    e_mod_move_bd_move_dim_objs_opacity_set(qp_data->dim_objs, opacity);
 871    qp_data->opacity = opacity;
 872    return EINA_TRUE;
 873 }
 874
 875 static Eina_Bool
 876 _e_mod_move_quickpanel_below_window_set(void)
 877 {
 878    E_Move *m;
 879    E_Move_Border *mb;
 880    E_Zone *zone = NULL;
 881    Eina_Bool found = EINA_FALSE;
 882
 883    m = e_mod_move_util_get();
 884    E_CHECK_RETURN(m, EINA_FALSE);
 885
 886    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 887      {
 888         if (!found && TYPE_QUICKPANEL_CHECK(mb))
 889           {
 890              found = EINA_TRUE;
 891              zone = mb->bd->zone;
 892           }
 893
 894         if (found)
 895           {
 896              if (!TYPE_QUICKPANEL_CHECK(mb)
 897                  && !TYPE_INDICATOR_CHECK(mb)
 898                  && !TYPE_APPTRAY_CHECK(mb)
 899                  && E_INTERSECTS(mb->x, mb->y, mb->w, mb->h,
 900                                  zone->x, zone->y, zone->w, zone->h)
 901                  && (mb->visible))
 902                {
 903                   L(LT_EVENT_OBJ,
 904                     "[MOVE] ev:%15.15s w:0x%08x %s() \n", "EVAS_OBJ",
 905                     mb->bd->win, __func__);
 906                   mb->animate_move = EINA_TRUE;
 907                }
 908           }
 909      }
 910    return found;
 911 }
 912
 913 static void
 914 _e_mod_move_quickpanel_below_window_unset(void)
 915 {
 916    E_Move *m;
 917    E_Move_Border *mb;
 918
 919    m = e_mod_move_util_get();
 920    E_CHECK(m);
 921
 922    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 923      {
 924         L(LT_EVENT_OBJ,
 925           "[MOVE] ev:%15.15s w:0x%08x %s() \n", "EVAS_OBJ",
 926           mb->bd->win, __func__);
 927         mb->animate_move = EINA_FALSE;
 928      }
 929 }
 930
 931 static Eina_Bool
 932 _e_mod_move_quickpanel_below_window_objs_add(void)
 933 {
 934    E_Move *m;
 935    E_Move_Border *mb;
 936    Eina_Bool mirror = EINA_TRUE;
 937    m = e_mod_move_util_get();
 938    E_CHECK_RETURN(m, EINA_FALSE);
 939
 940    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 941      {
 942         if (mb->animate_move)
 943           {
 944              if (!(mb->objs))
 945                {
 946                   L(LT_EVENT_OBJ,
 947                     "[MOVE] ev:%15.15s w:0x%08x %s() \n",
 948                     "EVAS_OBJ", mb->bd->win, __func__);
 949
 950                   if (TYPE_NOTIFICATION_CHECK(mb))
 951                     mb->objs = e_mod_move_bd_move_objs_add(mb, !mirror);
 952                   else
 953                     {
 954                        mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
 955                        e_mod_move_bd_move_objs_move(mb, mb->x, mb->y);
 956                        e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
 957                        e_mod_move_bd_move_objs_show(mb);
 958                     }
 959                }
 960           }
 961      }
 962
 963    return EINA_TRUE;
 964 }
 965
 966 static Eina_Bool
 967 _e_mod_move_quickpanel_below_window_objs_del(void)
 968 {
 969    E_Move *m;
 970    E_Move_Border *mb;
 971    m = e_mod_move_util_get();
 972    E_CHECK_RETURN(m, EINA_FALSE);
 973
 974    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
 975      {
 976         if (mb->animate_move)
 977           {
 978              L(LT_EVENT_OBJ,
 979                "[MOVE] ev:%15.15s w:0x%08x %s() \n",
 980                "EVAS_OBJ", mb->bd->win, __func__);
 981              e_mod_move_bd_move_objs_del(mb, mb->objs);
 982              mb->objs = NULL;
 983           }
 984      }
 985    return EINA_TRUE;
 986 }
 987
 988 static Eina_Bool
 989 _e_mod_move_quickpanel_below_window_objs_move(int x,
 990                                               int y)
 991 {
 992    E_Move *m;
 993    E_Move_Border *mb, *qp_mb;
 994    E_Zone *zone;
 995    int angle;
 996    int cx = 0, cy = 0, cw = 0, ch = 0;
 997    int mx = 0, my = 0;
 998    m = e_mod_move_util_get();
 999    E_CHECK_RETURN(m, EINA_FALSE);
1000    qp_mb = e_mod_move_quickpanel_find();
1001    E_CHECK_RETURN(qp_mb, EINA_FALSE);
1002
1003    if (!m->qp_scroll_with_clipping
1004         && !e_mod_move_border_contents_rect_get(qp_mb, &cx, &cy ,&cw, &ch))
1005      return EINA_FALSE;
1006
1007    angle = qp_mb->angle;
1008    zone = qp_mb->bd->zone;
1009
1010    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
1011      {
1012         if (mb->animate_move)
1013           {
1014              switch (angle)
1015                {
1016                 case   0:
1017                   mx = mb->x;
1018                   if (m->qp_scroll_with_clipping)
1019                     my = y + mb->y;
1020                   else
1021                     my = y + ch + mb->y;
1022                   break;
1023                 case  90:
1024                   if (m->qp_scroll_with_clipping)
1025                     mx = x + mb->x;
1026                   else
1027                     mx = x + cw + mb->x;
1028                   my = mb->y;
1029                   break;
1030                 case 180:
1031                   mx = mb->x;
1032                   if (m->qp_scroll_with_clipping)
1033                     my = mb->y - (zone->h - y);
1034                   else
1035                     my = y - ch + mb->y;
1036                   break;
1037                 case 270:
1038                   if (m->qp_scroll_with_clipping)
1039                     mx = mb->x - (zone->w - x);
1040                   else
1041                     mx = x - cw + mb->x;
1042                   my = mb->y;
1043                   break;
1044                 default :
1045                   break;
1046                }
1047              L(LT_EVENT_OBJ,
1048                "[MOVE] ev:%15.15s w:0x%08x %s()  (%d,%d)\n",
1049                "EVAS_OBJ", mb->bd->win, __func__, mx, my);
1050              e_mod_move_bd_move_objs_move(mb, mx, my);
1051           }
1052      }
1053
1054    // if qp_scroll_with_clipping case, make cw / ch data for e_mod_move_util_fb_move()
1055    if (m->qp_scroll_with_clipping)
1056      {
1057         switch (angle)
1058           {
1059            case 180:
1060               ch = zone->h;
1061               break;
1062            case 270:
1063               cw = zone->w;
1064               break;
1065            default:
1066               break;
1067           }
1068      }
1069
1070    e_mod_move_util_fb_move(angle, cw, ch, x, y);
1071
1072    return EINA_TRUE;
1073 }
1074
1075 static Eina_Bool
1076 _e_mod_move_quickpanel_handle_objs_add(E_Move_Border *mb)
1077 {
1078    E_Move *m = NULL;
1079    int hx = 0, hy = 0, hw = 0, hh = 0;
1080    E_Move_Quickpanel_Data *qp_data = NULL;
1081    E_CHECK_RETURN(mb, EINA_FALSE);
1082    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1083
1084    qp_data = (E_Move_Quickpanel_Data *)mb->data;
1085    E_CHECK_RETURN(qp_data, EINA_FALSE);
1086
1087    if (!e_mod_move_border_shape_input_rect_get(mb, &hx, &hy, &hw, &hh))
1088      return EINA_FALSE;
1089
1090    m = mb->m;
1091    qp_data->handle_objs = e_mod_move_evas_objs_add(m, mb->bd);
1092
1093    E_CHECK_RETURN(qp_data->handle_objs, EINA_FALSE);
1094
1095    e_mod_move_evas_objs_raise(qp_data->handle_objs);
1096    e_mod_move_evas_objs_move(qp_data->handle_objs, mb->x, mb->y);
1097    e_mod_move_evas_objs_resize(qp_data->handle_objs, mb->w, mb->h);
1098    e_mod_move_evas_objs_show(qp_data->handle_objs);
1099
1100    e_mod_move_evas_objs_clipper_add(qp_data->handle_objs);
1101    e_mod_move_evas_objs_clipper_move(qp_data->handle_objs, mb->x + hx, mb->y + hy);
1102    e_mod_move_evas_objs_clipper_resize(qp_data->handle_objs, hw, hh);
1103    e_mod_move_evas_objs_clipper_show(qp_data->handle_objs);
1104
1105    e_mod_move_evas_objs_del_cb_set(&(qp_data->handle_objs));
1106
1107    return EINA_TRUE;
1108 }
1109
1110 static Eina_Bool
1111 _e_mod_move_quickpanel_handle_objs_del(E_Move_Border *mb)
1112 {
1113    E_Move *m = NULL;
1114    E_Move_Quickpanel_Data *qp_data = NULL;
1115    E_CHECK_RETURN(mb, EINA_FALSE);
1116    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1117
1118    qp_data = (E_Move_Quickpanel_Data *)mb->data;
1119    E_CHECK_RETURN(qp_data, EINA_FALSE);
1120
1121    m = mb->m;
1122    E_CHECK_RETURN(qp_data->handle_objs,EINA_FALSE);
1123
1124    e_mod_move_evas_objs_clipper_hide(qp_data->handle_objs);
1125    e_mod_move_evas_objs_clipper_del(qp_data->handle_objs);
1126    e_mod_move_evas_objs_hide(qp_data->handle_objs);
1127    e_mod_move_evas_objs_del(qp_data->handle_objs);
1128
1129    qp_data->handle_objs = NULL;
1130
1131    return EINA_TRUE;
1132 }
1133
1134 static Eina_Bool
1135 _e_mod_move_quickpanel_handle_objs_size_update(E_Move_Border *mb,
1136                                                int            w,
1137                                                int            h)
1138 {
1139    E_Move_Quickpanel_Data *qp_data = NULL;
1140
1141    E_CHECK_RETURN(mb, EINA_FALSE);
1142    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1143
1144    qp_data = (E_Move_Quickpanel_Data *)mb->data;
1145    E_CHECK_RETURN(qp_data, EINA_FALSE);
1146
1147    E_CHECK_RETURN(qp_data->handle_objs,EINA_FALSE);
1148
1149    e_mod_move_evas_objs_clipper_resize(qp_data->handle_objs, w, h);
1150
1151    return EINA_TRUE;
1152 }
1153
1154 static Eina_Bool _e_mod_move_quickpanel_handle_objs_move(E_Move_Border *mb,
1155                                                          int            x,
1156                                                          int            y)
1157 {
1158    int hx = 0, hy = 0, hw = 0, hh = 0; // handle's x, y, w, h
1159    E_Zone *zone = NULL;
1160    E_Move *m = NULL;
1161    E_Move_Quickpanel_Data *qp_data = NULL;
1162    int angle =0;
1163    E_CHECK_RETURN(mb, EINA_FALSE);
1164    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1165
1166    qp_data = (E_Move_Quickpanel_Data *)mb->data;
1167    E_CHECK_RETURN(qp_data, EINA_FALSE);
1168
1169    m = mb->m;
1170    E_CHECK_RETURN(qp_data->handle_objs,EINA_FALSE);
1171
1172    if (!e_mod_move_border_shape_input_rect_get(mb, &hx, &hy, &hw, &hh))
1173      return EINA_FALSE;
1174
1175    angle = mb->angle;
1176    zone = mb->bd->zone;
1177    switch (angle)
1178      {
1179       case 90:
1180          e_mod_move_evas_objs_move(qp_data->handle_objs, x - mb->w + hw, zone->y);
1181          e_mod_move_evas_objs_clipper_move(qp_data->handle_objs, x, zone->y);
1182          break;
1183       case 180:
1184          e_mod_move_evas_objs_move(qp_data->handle_objs, zone->x, y - hh);
1185          e_mod_move_evas_objs_clipper_move(qp_data->handle_objs, zone->x, y - hh);
1186          // y - hh 's -hh means overlaping app's indicator region
1187          break;
1188       case 270:
1189          e_mod_move_evas_objs_move(qp_data->handle_objs, x - hw, zone->y);
1190          e_mod_move_evas_objs_clipper_move(qp_data->handle_objs, x - hw, zone->y);
1191          // x - hw 's -hw means overlaping app's indicator region
1192          break;
1193       case 0:
1194       default:
1195          e_mod_move_evas_objs_move(qp_data->handle_objs, zone->x, y - mb->h + hh);
1196          e_mod_move_evas_objs_clipper_move(qp_data->handle_objs, zone->x, y);
1197          break;
1198      }
1199
1200    return EINA_TRUE;
1201 }
1202
1203 // this function check moving objs go over screen or not
1204 static Eina_Bool
1205 _e_mod_move_quickpanel_objs_check_on_screen(E_Move_Border *mb,
1206                                             int            x,
1207                                             int            y)
1208 {
1209    E_Zone *zone = NULL;
1210    Eina_Bool ret = EINA_FALSE;
1211    int hx = 0, hy = 0, hw = 0, hh = 0; // handle's x, y, w, h
1212
1213    E_CHECK_RETURN(mb, FALSE);
1214    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), FALSE);
1215
1216    if (!e_mod_move_border_shape_input_rect_get(mb, &hx, &hy, &hw, &hh))
1217      return EINA_FALSE;
1218
1219    zone = mb->bd->zone;
1220    switch (mb->angle)
1221      {
1222        // don't go over screen
1223       case 90:
1224          if (x + hw <= zone->x + zone->w) ret = EINA_TRUE;
1225          break;
1226       case 180:
1227          if (y - hh >= zone->y) ret = EINA_TRUE;
1228          break;
1229       case 270:
1230          if (x - hw >= zone->x) ret = EINA_TRUE;
1231          break;
1232       case 0:
1233       default:
1234          if (y + hh <= zone->y + zone->h) ret = EINA_TRUE;
1235          break;
1236      }
1237    return ret;
1238 }
1239
1240 static Eina_Bool
1241 _e_mod_move_quickpanel_animation_change_with_angle(E_Move_Border *mb)
1242 {
1243    E_Move *m = NULL;
1244    E_Border *bd = NULL;
1245    int ax = 0, ay = 0; // animation x, animation y
1246    int px = 0, py = 0; // position x, position y
1247    int cx = 0, cy = 0, cw = 0, ch = 0;
1248    int curr_angle = 0, prev_angle = 0;
1249    double dist_rate = 0.0;
1250    E_Zone *zone = NULL;
1251
1252    E_CHECK_RETURN(mb, EINA_FALSE);
1253    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1254
1255    m = mb->m;
1256    E_CHECK_RETURN(m, EINA_FALSE);
1257    bd = mb->bd;
1258    E_CHECK_RETURN(bd, EINA_FALSE);
1259    zone = bd->zone;
1260    E_CHECK_RETURN(zone, EINA_FALSE);
1261
1262    if (!e_mod_move_util_win_prop_angle_get(bd->client.win,
1263                                            &curr_angle,
1264                                            &prev_angle))
1265      return EINA_FALSE;
1266
1267    if (!e_mod_move_quickpanel_objs_animation_state_get(mb))
1268      return EINA_FALSE;
1269
1270    if (!_e_mod_move_quickpanel_objs_moving_distance_rate_get(mb, prev_angle, &dist_rate))
1271      return EINA_FALSE;
1272
1273    // new_position set with distance rate
1274    switch (curr_angle)
1275      {
1276       case  90:
1277          if (m->qp_scroll_with_clipping)
1278            px = (dist_rate * (zone->x + zone->w));
1279          else
1280            {
1281               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1282                 px = (dist_rate * (zone->x + zone->w)) - cw;
1283               else
1284                 px = (dist_rate * (zone->x + zone->w)) - mb->w;
1285            }
1286          break;
1287       case 180:
1288          if (m->qp_scroll_with_clipping)
1289            py = (1.0 - dist_rate) * (zone->y + zone->h);
1290          else
1291            {
1292               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1293                 py = (1.0 - dist_rate) * (zone->y + zone->h) - cy;
1294               else
1295                 py = (1.0 - dist_rate) * (zone->y + zone->h);
1296            }
1297          break;
1298       case 270:
1299          if (m->qp_scroll_with_clipping)
1300            px = (1.0 - dist_rate) * (zone->x + zone->w);
1301          else
1302            {
1303               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1304                 px = (1.0 - dist_rate) * (zone->x + zone->w) - ch;
1305               else
1306                 px = (1.0 - dist_rate) * (zone->x + zone->w);
1307            }
1308          break;
1309       case   0:
1310       default :
1311          if (m->qp_scroll_with_clipping)
1312            py = (dist_rate * (zone->y + zone->h));
1313          else
1314            {
1315               if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1316                 py = (dist_rate * (zone->y + zone->h)) - ch;
1317               else
1318                 py = (dist_rate * (zone->y + zone->h)) - mb->h;
1319            }
1320          break;
1321      }
1322    _e_mod_move_quickpanel_objs_position_set(mb, px, py);
1323
1324    // set info for new animation
1325    switch(e_mod_move_quickpanel_objs_animation_direction_get(mb))
1326      {
1327         case E_MOVE_ANIMATION_DIRECTION_INSIDE:
1328               switch (curr_angle)
1329                 {
1330                  case 180:
1331                  case 270:
1332                     if (m->qp_scroll_with_clipping)
1333                       {
1334                         ax = zone->x;
1335                         ay = zone->y;
1336                       }
1337                     break;
1338                  case   0:
1339                  case  90:
1340                  default :
1341                     if (m->qp_scroll_with_clipping)
1342                       {
1343                         ax = zone->x + mb->w;
1344                         ay = zone->y + mb->h;
1345                      }
1346                     break;
1347                 }
1348            break;
1349         case E_MOVE_ANIMATION_DIRECTION_OUTSIDE:
1350            {
1351               switch (curr_angle)
1352                 {
1353                  case  90:
1354                     if (m->qp_scroll_with_clipping)
1355                       {
1356                          ax = zone->x; ay = zone->y;
1357                       }
1358                     else
1359                       {
1360                          ax = mb->w * -1;
1361                       }
1362                     break;
1363                  case 180:
1364                     if (m->qp_scroll_with_clipping)
1365                       {
1366                          ax = zone->x + mb->w;
1367                          ay = zone->y + mb->h;
1368                       }
1369                     else
1370                       {
1371                          ay = zone->h;
1372                       }
1373                     break;
1374                  case 270:
1375                     if (m->qp_scroll_with_clipping)
1376                       {
1377                          ax = zone->x + mb->w;
1378                          ay = zone->y + mb->h;
1379                       }
1380                     else
1381                       {
1382                          ax = zone->w;
1383                       }
1384                     break;
1385                  case   0:
1386                  default :
1387                     if (m->qp_scroll_with_clipping)
1388                       {
1389                          ax = zone->x; ay = zone->y;
1390                       }
1391                     else
1392                       {
1393                          ay = mb->h * -1;
1394                       }
1395                     break;
1396                 }
1397            }
1398            break;
1399         case E_MOVE_ANIMATION_DIRECTION_NONE:
1400         default:
1401            return EINA_FALSE;
1402      }
1403
1404    e_mod_move_quickpanel_objs_animation_stop(mb);
1405    e_mod_move_quickpanel_objs_animation_clear(mb);
1406    e_mod_move_quickpanel_objs_add(mb);
1407
1408    //prevent handler object flickering, if input region update, then show handler again.
1409    _e_mod_move_quickpanel_handle_objs_size_update(mb, 0, 0);
1410
1411    e_mod_move_quickpanel_objs_animation_move(mb, ax, ay);
1412    return EINA_TRUE;
1413 }
1414
1415 static Eina_Bool
1416 _e_mod_move_quickpanel_fb_move_change_with_angle(E_Move_Border *mb)
1417 {
1418    E_Move *m = NULL;
1419    E_Border *bd = NULL;
1420    int ax = 0, ay = 0;
1421    int cx = 0, cy = 0, cw = 0, ch = 0;
1422    int curr_angle = 0, prev_angle = 0;
1423    E_Zone *zone = NULL;
1424
1425    E_CHECK_RETURN(mb, EINA_FALSE);
1426    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1427
1428    m = mb->m;
1429    E_CHECK_RETURN(m, EINA_FALSE);
1430    bd = mb->bd;
1431    E_CHECK_RETURN(bd, EINA_FALSE);
1432    zone = bd->zone;
1433    E_CHECK_RETURN(zone, EINA_FALSE);
1434
1435    if (!e_mod_move_util_win_prop_angle_get(bd->client.win,
1436                                            &curr_angle,
1437                                            &prev_angle))
1438      return EINA_FALSE;
1439
1440    if (e_mod_move_quickpanel_objs_animation_state_get(mb))
1441      return EINA_FALSE;
1442
1443    if (!E_INTERSECTS(bd->x, bd->y, bd->w, bd->h,
1444                      zone->x, zone->y, zone->w, zone->h)) // it work when quickpanel exists inside zone
1445      return EINA_FALSE;
1446
1447    // if none-clipping scroll and none-content-rect then return, because there are not scroll info
1448    if (!m->qp_scroll_with_clipping
1449         && !e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1450      return EINA_FALSE;
1451
1452    switch (curr_angle)
1453      {
1454       case  90:
1455          if (m->qp_scroll_with_clipping)
1456            {
1457               ax = zone->x + mb->w;
1458               ay = zone->y + mb->h;
1459            }
1460          break;
1461       case 180:
1462          if (m->qp_scroll_with_clipping)
1463            {
1464               ax = zone->x; ay = zone->y;
1465            }
1466          else
1467            {
1468               ay = zone->h - mb->h;
1469            }
1470          break;
1471       case 270:
1472          if (m->qp_scroll_with_clipping)
1473            {
1474               ax = zone->x; ay = zone->y;
1475            }
1476          else
1477            {
1478               ax = zone->w - mb->w;
1479            }
1480          break;
1481       case   0:
1482       default :
1483          if (m->qp_scroll_with_clipping)
1484            {
1485               ax = zone->x + mb->w;
1486               ay = zone->y + mb->h;
1487            }
1488          break;
1489      }
1490
1491    if (m->qp_scroll_with_clipping)
1492      {
1493         switch (curr_angle)
1494           {
1495            case 180:
1496               ch = zone->h;
1497               break;
1498            case 270:
1499               cw = zone->w;
1500               break;
1501            default:
1502               break;
1503           }
1504      }
1505
1506    e_mod_move_util_fb_move(curr_angle, cw, ch, ax, ay);
1507
1508    return EINA_TRUE;
1509 }
1510
1511 static Eina_Bool
1512 _e_mod_move_quickpanel_comp_layer_obj_move(int x,
1513                                            int y)
1514 {
1515    E_Move *m;
1516    E_Move_Border *qp_mb;
1517    E_Zone *zone;
1518    int angle;
1519    int cx = 0, cy = 0, cw = 0, ch = 0;
1520    int mx = 0, my = 0;
1521    m = e_mod_move_util_get();
1522    E_CHECK_RETURN(m, EINA_FALSE);
1523    qp_mb = e_mod_move_quickpanel_find();
1524    E_CHECK_RETURN(qp_mb, EINA_FALSE);
1525    if (!m->qp_scroll_with_clipping
1526         && !e_mod_move_border_contents_rect_get(qp_mb, &cx, &cy ,&cw, &ch))
1527      return EINA_FALSE;
1528
1529    angle = qp_mb->angle;
1530    zone = qp_mb->bd->zone;
1531
1532    switch (angle)
1533      {
1534       case   0:
1535          mx = zone->x;
1536          if (m->qp_scroll_with_clipping)
1537             my = y + zone->y;
1538          else
1539             my = y + ch + zone->y;
1540          break;
1541       case  90:
1542          if (m->qp_scroll_with_clipping)
1543             mx = x + zone->x;
1544          else
1545             mx = x + cw + zone->x;
1546          my = zone->y;
1547          break;
1548       case 180:
1549          mx = zone->x;
1550          if (m->qp_scroll_with_clipping)
1551             my = zone->y - (zone->h - y);
1552          else
1553             my = y - ch + zone->y;
1554          break;
1555       case 270:
1556          if (m->qp_scroll_with_clipping)
1557             mx = zone->x - (zone->w - x);
1558          else
1559             mx = x - cw + zone->x;
1560          my = zone->y;
1561          break;
1562       default :
1563          break;
1564      }
1565
1566    _e_mod_move_quickpanel_comp_layer_obj_move_intern(mx, my);
1567
1568    // if qp_scroll_with_clipping case, make cw / ch data for e_mod_move_util_fb_move()
1569    if (m->qp_scroll_with_clipping)
1570      {
1571         switch (angle)
1572           {
1573            case 180:
1574               ch = zone->h;
1575               break;
1576            case 270:
1577               cw = zone->w;
1578               break;
1579            default:
1580               break;
1581           }
1582      }
1583
1584    e_mod_move_util_fb_move(angle, cw, ch, x, y);
1585
1586    return EINA_TRUE;
1587 }
1588
1589 static Eina_Bool
1590 _e_mod_move_quickpanel_comp_layer_obj_move_intern(int x,
1591                                                   int y)
1592 {
1593    E_Move *m = NULL;
1594    Evas_Object *comp_layer = NULL;
1595    Evas_Object *effect_layer = NULL;
1596
1597    m = e_mod_move_util_get();
1598    E_CHECK_RETURN(m, EINA_FALSE);
1599
1600    comp_layer = e_mod_move_util_comp_layer_get(m, "comp");
1601    if (comp_layer)
1602      {
1603          evas_object_move(comp_layer, x, y);
1604          L(LT_EVENT_OBJ,
1605            "[MOVE] ev:%15.15s comp_layer_obj:0x%x %s()  (%d,%d)\n",
1606            "EVAS_OBJ", comp_layer, __func__, x, y);
1607      }
1608
1609
1610    effect_layer = e_mod_move_util_comp_layer_get(m, "effect");
1611    if (effect_layer)
1612      {
1613          evas_object_move(effect_layer, x, y);
1614          L(LT_EVENT_OBJ,
1615            "[MOVE] ev:%15.15s effect_layer_obj:0x%x %s()  (%d,%d)\n",
1616            "EVAS_OBJ", effect_layer, __func__, x, y);
1617      }
1618
1619    return EINA_TRUE;
1620 }
1621
1622 /* externally accessible functions */
1623 EINTERN void
1624 e_mod_move_quickpanel_ctl_obj_event_setup(E_Move_Border         *mb,
1625                                           E_Move_Control_Object *mco)
1626 {
1627    E_CHECK(mb);
1628    E_CHECK(mco);
1629    E_CHECK(TYPE_QUICKPANEL_CHECK(mb));
1630
1631    mco->event = e_mod_move_event_new(mb->bd->client.win, mco->obj);
1632    E_CHECK(mco->event);
1633
1634    e_mod_move_event_data_type_set(mco->event, E_MOVE_EVENT_DATA_TYPE_BORDER);
1635    e_mod_move_event_angle_cb_set(mco->event,
1636                                  e_mod_move_util_win_prop_angle_get);
1637    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_START,
1638                            _e_mod_move_quickpanel_cb_motion_start, mb);
1639    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_MOVE,
1640                            _e_mod_move_quickpanel_cb_motion_move, mb);
1641    e_mod_move_event_cb_set(mco->event, E_MOVE_EVENT_TYPE_MOTION_END,
1642                            _e_mod_move_quickpanel_cb_motion_end, mb);
1643    e_mod_move_event_propagate_type_set(mco->event,
1644                                        E_MOVE_EVENT_PROPAGATE_TYPE_IMMEDIATELY);
1645 }
1646
1647 EINTERN E_Move_Border *
1648 e_mod_move_quickpanel_base_find(void)
1649 {
1650    E_Move *m;
1651    E_Move_Border *mb;
1652
1653    m = e_mod_move_util_get();
1654    E_CHECK_RETURN(m, 0);
1655
1656    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
1657      {
1658         if (TYPE_QUICKPANEL_BASE_CHECK(mb)) return mb;
1659      }
1660    return NULL;
1661 }
1662
1663 EINTERN E_Move_Border *
1664 e_mod_move_quickpanel_find(void)
1665 {
1666    E_Move *m;
1667    E_Move_Border *mb;
1668
1669    m = e_mod_move_util_get();
1670    E_CHECK_RETURN(m, 0);
1671
1672    EINA_INLIST_REVERSE_FOREACH(m->borders, mb)
1673      {
1674         if (TYPE_QUICKPANEL_CHECK(mb)) return mb;
1675      }
1676    return NULL;
1677 }
1678
1679 EINTERN Eina_Bool
1680 e_mod_move_quickpanel_click_get(void)
1681 {
1682    E_Move_Border         *mb = NULL;
1683    Eina_Bool              click = EINA_FALSE;
1684    E_Move_Control_Object *mco = NULL;
1685    Eina_List             *l;
1686
1687    mb = e_mod_move_quickpanel_find();
1688    E_CHECK_RETURN(mb, EINA_FALSE);
1689
1690    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
1691      {
1692         if (!mco) continue;
1693         click = e_mod_move_event_click_get(mco->event);
1694      }
1695
1696    return click;
1697 }
1698
1699 EINTERN Eina_Bool
1700 e_mod_move_quickpanel_event_clear(void)
1701 {
1702    E_Move_Border         *mb = NULL;
1703    Eina_Bool              click = EINA_FALSE;
1704    E_Move_Control_Object *mco = NULL;
1705    Eina_List             *l;
1706
1707    mb = e_mod_move_quickpanel_find();
1708    E_CHECK_RETURN(mb, EINA_FALSE);
1709
1710    click = e_mod_move_quickpanel_click_get();
1711    E_CHECK_RETURN(click, EINA_FALSE);
1712
1713    EINA_LIST_FOREACH(mb->ctl_objs, l, mco)
1714      {
1715         if (!mco) continue;
1716         e_mod_move_event_data_clear(mco->event);
1717         e_mod_move_event_click_set(mco->event, EINA_FALSE);
1718      }
1719
1720    if (mb->flick_data) e_mod_move_flick_data_free(mb);
1721
1722    return EINA_TRUE;
1723 }
1724
1725 EINTERN Eina_Bool
1726 e_mod_move_quickpanel_objs_add(E_Move_Border *mb)
1727 {
1728    E_Move *m = NULL;
1729    Eina_Bool mirror = EINA_TRUE;
1730    Evas_Object *move_layer = NULL;
1731    E_CHECK_RETURN(mb, EINA_FALSE);
1732    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1733
1734    m = mb->m;
1735
1736    move_layer = e_mod_move_util_comp_layer_get(m, "move");
1737    E_CHECK_RETURN(move_layer, EINA_FALSE);
1738
1739    if (!(mb->objs))
1740      {
1741         mb->objs = e_mod_move_bd_move_objs_add(mb, mirror);
1742         e_mod_move_bd_move_objs_move(mb, mb->x, mb->y);
1743         e_mod_move_bd_move_objs_resize(mb, mb->w, mb->h);
1744         e_mod_move_bd_move_objs_show(mb);
1745
1746         e_mod_move_util_screen_input_block(m);
1747
1748         if (!evas_object_visible_get(move_layer))
1749           evas_object_show(move_layer);
1750
1751         if (mb->objs) e_mod_move_util_rotation_lock(mb->m);
1752
1753         if (m->qp_scroll_with_clipping)
1754           {
1755              e_mod_move_quickpanel_objs_clipper_add(mb);
1756              _e_mod_move_quickpanel_handle_objs_add(mb);
1757           }
1758      }
1759    return EINA_TRUE;
1760 }
1761
1762 EINTERN Eina_Bool
1763 e_mod_move_quickpanel_objs_del(E_Move_Border *mb)
1764 {
1765    E_Move *m = NULL;
1766    Evas_Object *move_layer = NULL;
1767    E_CHECK_RETURN(mb, EINA_FALSE);
1768    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1769    m = mb->m;
1770
1771    move_layer = e_mod_move_util_comp_layer_get(m, "move");
1772    E_CHECK_RETURN(move_layer, EINA_FALSE);
1773
1774     if (evas_object_visible_get(move_layer))
1775       evas_object_hide(move_layer);
1776
1777    if (m->qp_scroll_with_clipping)
1778      {
1779         e_mod_move_quickpanel_objs_clipper_del(mb);
1780         _e_mod_move_quickpanel_handle_objs_del(mb);
1781      }
1782
1783    e_mod_move_bd_move_objs_del(mb, mb->objs);
1784    e_mod_move_util_rotation_unlock(mb->m);
1785    e_mod_move_util_screen_input_unblock(mb->m);
1786
1787    mb->objs = NULL;
1788
1789    return EINA_TRUE;
1790 }
1791
1792 EINTERN Eina_Bool
1793 e_mod_move_quickpanel_objs_move(E_Move_Border *mb,
1794                                 int            x,
1795                                 int            y)
1796 {
1797    E_Move *m = NULL;
1798    E_Zone *zone = NULL;
1799    int cx = 0, cy = 0, cw = 0, ch = 0;
1800
1801    E_CHECK_RETURN(mb, EINA_FALSE);
1802    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1803
1804    m = mb->m;
1805    zone = mb->bd->zone;
1806
1807    _e_mod_move_quickpanel_objs_position_set(mb, x, y);
1808
1809    // QP UX
1810    if (m->qp_scroll_with_clipping)
1811      {
1812         e_mod_move_bd_move_objs_move(mb, zone->x, zone->y); // in general, zone->x:0, zone->y: 0
1813         e_mod_move_quickpanel_objs_clipper_apply(mb, x, y); // move clipper
1814
1815         // check handle & below window don't go over screen
1816         if (!_e_mod_move_quickpanel_objs_check_on_screen(mb, x , y))
1817           return EINA_FALSE;
1818
1819         _e_mod_move_quickpanel_handle_objs_move(mb, x, y);; // move handle (mirror with clipper) object
1820
1821         if (m->qp_scroll_with_visible_win)
1822           {
1823              if (POINT_INSIDE_ZONE(x, y, zone))
1824                _e_mod_move_quickpanel_comp_layer_obj_move(x, y);
1825           }
1826      }
1827    else
1828      {
1829         e_mod_move_bd_move_objs_move(mb, x, y);
1830         _e_mod_move_quickpanel_dim_objs_apply(mb, x, y);
1831
1832         if (m->qp_scroll_with_visible_win)
1833           {
1834              if (e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch))
1835                {
1836                   if (E_INTERSECTS(x+cx, y+cy, cw, ch, zone->x, zone->y, zone->w, zone->h))
1837                     _e_mod_move_quickpanel_comp_layer_obj_move(x, y);
1838                }
1839           }
1840      }
1841    return EINA_TRUE;
1842 }
1843
1844 EINTERN Eina_Bool
1845 e_mod_move_quickpanel_objs_animation_move_with_time(E_Move_Border *mb,
1846                                                     int            x,
1847                                                     int            y,
1848                                                     double         anim_time)
1849 {
1850    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
1851    Ecore_Animator *animator = NULL;
1852    int sx, sy; //start x, start y
1853    int angle = 0;
1854
1855    E_CHECK_RETURN(mb, EINA_FALSE);
1856    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1857    E_CHECK_RETURN(mb->m, EINA_FALSE);
1858
1859    if (e_mod_move_quickpanel_objs_animation_state_get(mb))
1860      {
1861         e_mod_move_quickpanel_objs_animation_stop(mb);
1862         e_mod_move_quickpanel_objs_animation_clear(mb);
1863      }
1864
1865    anim_data = E_NEW(E_Move_Quickpanel_Animation_Data, 1);
1866    E_CHECK_RETURN(anim_data, EINA_FALSE);
1867
1868    if (_e_mod_move_quickpanel_objs_position_get(mb, &sx, &sy))
1869      {
1870         anim_data->sx = sx;
1871         anim_data->sy = sy;
1872      }
1873    else
1874      {
1875         // below cases are quickpanel is on screen case, so set start position with quickpanel's screen position
1876         if (mb->m->qp_scroll_with_clipping)
1877           {
1878              angle = mb->angle;
1879              switch (angle)
1880                {
1881                  case 0:
1882                  case 90:
1883                  default:
1884                      anim_data->sx = mb->x + mb->w;
1885                      anim_data->sy = mb->y + mb->h;
1886                      break;
1887                  case 180:
1888                  case 270:
1889                      anim_data->sx = mb->x;
1890                      anim_data->sy = mb->y;
1891                      break;
1892                }
1893           }
1894         else
1895           {
1896              anim_data->sx = mb->x;
1897              anim_data->sy = mb->y;
1898           }
1899         _e_mod_move_quickpanel_objs_position_set(mb,
1900                                                  anim_data->sx,
1901                                                  anim_data->sy);
1902      }
1903
1904    anim_data->ex = x;
1905    anim_data->ey = y;
1906    anim_data->dx = anim_data->ex - anim_data->sx;
1907    anim_data->dy = anim_data->ey - anim_data->sy;
1908
1909    animator = ecore_animator_timeline_add(anim_time,
1910                                           _e_mod_move_quickpanel_objs_animation_frame,
1911                                           anim_data);
1912    if (!animator)
1913      {
1914         memset(anim_data, 0, sizeof(E_Move_Quickpanel_Animation_Data));
1915         E_FREE(anim_data);
1916         return EINA_FALSE;
1917      }
1918
1919    anim_data->animator = animator;
1920    anim_data->animating = EINA_TRUE;
1921    mb->anim_data = anim_data;
1922
1923    return EINA_TRUE;
1924 }
1925
1926 EINTERN Eina_Bool
1927 e_mod_move_quickpanel_objs_animation_move(E_Move_Border *mb,
1928                                           int            x,
1929                                           int            y)
1930 {
1931    double anim_time = 0.0;
1932
1933    E_CHECK_RETURN(mb, EINA_FALSE);
1934    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1935    E_CHECK_RETURN(mb->m, EINA_FALSE);
1936    anim_time = mb->m->animation_duration;
1937    return e_mod_move_quickpanel_objs_animation_move_with_time(mb, x, y, anim_time);
1938 }
1939
1940 EINTERN Eina_Bool
1941 e_mod_move_quickpanel_objs_animation_state_get(E_Move_Border *mb)
1942 {
1943    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
1944    E_CHECK_RETURN(mb, EINA_FALSE);
1945    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1946
1947    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
1948    anim_data = (E_Move_Quickpanel_Animation_Data *)mb->anim_data;
1949    E_CHECK_RETURN(anim_data->animating, EINA_FALSE);
1950    return EINA_TRUE;
1951 }
1952
1953 EINTERN E_Move_Animation_Direction
1954 e_mod_move_quickpanel_objs_animation_direction_get(E_Move_Border *mb)
1955 {
1956    E_Border *bd = NULL;
1957    E_Zone *zone = NULL;
1958    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
1959    E_CHECK_RETURN(mb, E_MOVE_ANIMATION_DIRECTION_NONE);
1960    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), E_MOVE_ANIMATION_DIRECTION_NONE);
1961    bd= mb->bd;
1962    E_CHECK_RETURN(bd, E_MOVE_ANIMATION_DIRECTION_NONE);
1963    zone = bd->zone;
1964    E_CHECK_RETURN(zone, E_MOVE_ANIMATION_DIRECTION_NONE);
1965    E_CHECK_RETURN(mb->anim_data, E_MOVE_ANIMATION_DIRECTION_NONE);
1966    anim_data = (E_Move_Quickpanel_Animation_Data *)mb->anim_data;
1967
1968    if (E_INTERSECTS(bd->x, bd->y, bd->w, bd->h,
1969                     zone->x, zone->y, zone->w, zone->h))
1970      {
1971         // animation's end position is inside zone.
1972         return E_MOVE_ANIMATION_DIRECTION_INSIDE;
1973      }
1974    else
1975      {
1976         // animation's end position is outside zone.
1977         return E_MOVE_ANIMATION_DIRECTION_OUTSIDE;
1978      }
1979 }
1980
1981 EINTERN Eina_Bool
1982 e_mod_move_quickpanel_objs_animation_stop(E_Move_Border *mb)
1983 {
1984    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
1985    E_CHECK_RETURN(mb, EINA_FALSE);
1986    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
1987
1988    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
1989    anim_data = (E_Move_Quickpanel_Animation_Data *)mb->anim_data;
1990    ecore_animator_freeze(anim_data->animator);
1991    return EINA_TRUE;
1992 }
1993
1994 EINTERN Eina_Bool
1995 e_mod_move_quickpanel_objs_animation_clear(E_Move_Border *mb)
1996 {
1997    E_Move_Quickpanel_Animation_Data *anim_data = NULL;
1998    E_CHECK_RETURN(mb, EINA_FALSE);
1999    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2000
2001    E_CHECK_RETURN(mb->anim_data, EINA_FALSE);
2002    anim_data = (E_Move_Quickpanel_Animation_Data *)mb->anim_data;
2003    ecore_animator_del(anim_data->animator);
2004    memset(anim_data, 0, sizeof(E_Move_Quickpanel_Animation_Data));
2005    E_FREE(anim_data);
2006    mb->anim_data = NULL;
2007
2008    return EINA_TRUE;
2009 }
2010
2011 EINTERN void*
2012 e_mod_move_quickpanel_internal_data_add(E_Move_Border *mb)
2013 {
2014    int dim_min;
2015    E_Move_Quickpanel_Data *qp_data = NULL;
2016    E_CHECK_RETURN(mb, NULL);
2017    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), NULL);
2018    E_CHECK_RETURN(mb->m, NULL);
2019    dim_min = mb->m->dim_min_opacity;
2020    qp_data = (E_Move_Quickpanel_Data *)mb->data;
2021    if (!qp_data)
2022      {
2023         qp_data = E_NEW(E_Move_Quickpanel_Data, 1);
2024         E_CHECK_RETURN(qp_data, NULL);
2025         qp_data->x = mb->x;
2026         qp_data->y = mb->y;
2027         qp_data->dim_objs = NULL;
2028         qp_data->opacity = dim_min;
2029         mb->data = qp_data;
2030      }
2031    return mb->data;
2032 }
2033
2034 EINTERN Eina_Bool
2035 e_mod_move_quickpanel_internal_data_del(E_Move_Border *mb)
2036 {
2037    E_Move_Quickpanel_Data *qp_data = NULL;
2038    E_CHECK_RETURN(mb, EINA_FALSE);
2039    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2040    E_CHECK_RETURN(mb->data, EINA_FALSE);
2041    qp_data = (E_Move_Quickpanel_Data *)mb->data;
2042
2043    if (mb->m->qp_scroll_with_clipping) // "scroll with clipping" uses handle objs so delete here.
2044      {
2045         _e_mod_move_quickpanel_handle_objs_del(mb);
2046      }
2047    else // general quickpanel scroll uses dim objs so delete here.
2048      {
2049         e_mod_move_quickpanel_dim_hide(mb);
2050      }
2051
2052    // Set No Composite Mode & Rotation UnLock & Destroy below win's mirror object
2053    e_mod_move_quickpanel_stage_deinit(mb);
2054
2055    E_FREE(qp_data);
2056    mb->data = NULL;
2057    return EINA_TRUE;
2058 }
2059
2060 EINTERN Eina_Bool
2061 e_mod_move_quickpanel_e_border_move(E_Move_Border *mb,
2062                                     int            x,
2063                                     int            y)
2064 {
2065    E_Move        *m = NULL;
2066    E_Border      *bd = NULL;
2067    E_Zone        *zone = NULL;
2068    E_Move_Border *find_mb = NULL;
2069    Ecore_X_Window win;
2070    E_CHECK_RETURN(mb, EINA_FALSE);
2071    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2072    E_CHECK_RETURN(mb->bd, EINA_FALSE);
2073    m = mb->m;
2074    bd = mb->bd;
2075    zone = bd->zone;
2076
2077    if (E_CONTAINS(zone->x, zone->y, zone->w, zone->h, x, y, mb->w, mb->h))// On Screen Case, if zone contains border geometry?
2078      {
2079         win = e_mod_move_util_client_xid_get(mb);
2080
2081         EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
2082           {
2083              if (find_mb->visible)
2084                {
2085                   if (find_mb->bd)
2086                      ecore_x_e_illume_quickpanel_state_send(find_mb->bd->client.win,
2087                                                             ECORE_X_ILLUME_QUICKPANEL_STATE_ON);
2088                }
2089              else
2090                {
2091                   if (find_mb->bd && find_mb->bd->iconic)
2092                      ecore_x_e_illume_quickpanel_state_send(find_mb->bd->client.win,
2093                                                             ECORE_X_ILLUME_QUICKPANEL_STATE_ON);
2094                }
2095           }
2096
2097         ecore_x_e_illume_quickpanel_state_set(zone->black_win, ECORE_X_ILLUME_QUICKPANEL_STATE_ON);
2098      }
2099
2100    e_border_move(bd, x, y);
2101
2102    return EINA_TRUE;
2103 }
2104
2105 EINTERN Eina_List*
2106 e_mod_move_quickpanel_dim_show(E_Move_Border *mb)
2107 {
2108    int dim_min;
2109    E_Move *m = NULL;
2110    E_Move_Quickpanel_Data *qp_data = NULL;
2111    E_CHECK_RETURN(mb, NULL);
2112    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), NULL);
2113    qp_data = (E_Move_Quickpanel_Data *)mb->data;
2114    m = mb->m;
2115    dim_min = m->dim_min_opacity;
2116    if (!qp_data)
2117      {
2118         qp_data = E_NEW(E_Move_Quickpanel_Data, 1);
2119         E_CHECK_RETURN(qp_data, NULL);
2120
2121         qp_data->x = mb->x;
2122         qp_data->y = mb->y;
2123         qp_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
2124         e_mod_move_bd_move_dim_objs_show(qp_data->dim_objs);
2125         qp_data->opacity = dim_min;
2126         mb->data = qp_data;
2127      }
2128    else
2129      {
2130         if (!(qp_data->dim_objs))
2131           qp_data->dim_objs = e_mod_move_bd_move_dim_objs_add(mb);
2132
2133         if (qp_data->dim_objs)
2134           {
2135              e_mod_move_bd_move_dim_objs_show(qp_data->dim_objs);
2136              qp_data->opacity = dim_min;
2137           }
2138      }
2139
2140    L(LT_EVENT_OBJ,
2141      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
2142      "EVAS_OBJ", mb->bd ? mb->bd->win : 0, __func__);
2143
2144    return qp_data->dim_objs;
2145 }
2146
2147 EINTERN Eina_Bool
2148 e_mod_move_quickpanel_dim_hide(E_Move_Border *mb)
2149 {
2150    int dim_min;
2151    E_Move *m = NULL;
2152    E_Move_Quickpanel_Data *qp_data = NULL;
2153    E_CHECK_RETURN(mb, EINA_FALSE);
2154    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2155    E_CHECK_RETURN(mb->m, EINA_FALSE);
2156    E_CHECK_RETURN(mb->data, EINA_FALSE);
2157    dim_min =  mb->m->dim_min_opacity;
2158    qp_data = (E_Move_Quickpanel_Data *)mb->data;
2159    E_CHECK_RETURN(qp_data->dim_objs, EINA_FALSE);
2160    e_mod_move_bd_move_dim_objs_hide(qp_data->dim_objs);
2161    e_mod_move_bd_move_dim_objs_del(qp_data->dim_objs);
2162    qp_data->dim_objs = NULL;
2163    qp_data->opacity = dim_min;
2164    m = mb->m;
2165
2166    L(LT_EVENT_OBJ,
2167      "[MOVE] ev:%15.15s w:0x%08x %s()\n",
2168      "EVAS_OBJ", ((mb->bd) ? mb->bd->win : NULL), __func__);
2169
2170    return EINA_TRUE;
2171 }
2172
2173 EINTERN Eina_Bool
2174 e_mod_move_quickpanel_objs_animation_start_position_set(E_Move_Border *mb,
2175                                                        int             angle)
2176 {
2177    int x = 0; int y = 0;
2178    int cx = 0; int cy = 0; int cw = 0; int ch = 0;
2179    E_Zone *zone = NULL;
2180    E_Move *m = NULL;
2181    Eina_Bool contents;
2182
2183    E_CHECK_RETURN(mb, EINA_FALSE);
2184    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2185
2186    m = mb->m;
2187    zone = mb->bd->zone;
2188    angle = ((angle % 360) / 90) * 90;
2189    contents = e_mod_move_border_contents_rect_get(mb, &cx, &cy ,&cw, &ch);
2190
2191    if (m->qp_scroll_with_clipping)
2192      {
2193        switch (angle)
2194          {
2195           case 0:
2196           case 90:
2197           default:
2198              x = mb->x; y = mb->y;
2199              break;
2200           case 180:
2201           case 270:
2202              x = mb->x + mb->w; y = mb->y + mb->h;
2203              break;
2204           }
2205      }
2206    else
2207      {
2208         switch (angle)
2209           {
2210            case  90:
2211               if (contents)
2212                  x = cw * -1;
2213               else
2214                  x = mb->w * -1;
2215               break;
2216            case 180:
2217               if (contents)
2218                  y = zone->y + zone->h - cy;
2219               else
2220                  y = zone->y + zone->h;
2221               break;
2222            case 270:
2223               if (contents)
2224                  x = zone->x + zone->w - cx;
2225               else
2226                  x = zone->x + zone->w;
2227               break;
2228            case   0:
2229            default :
2230               if (contents)
2231                  y = ch * -1;
2232               else
2233                  y = mb->h * -1;
2234               break;
2235           }
2236      }
2237
2238    _e_mod_move_quickpanel_objs_position_set(mb, x, y);
2239
2240    return EINA_TRUE;
2241 }
2242
2243 EINTERN E_Move_Event_Cb
2244 e_mod_move_quickpanel_event_cb_get(E_Move_Event_Type type)
2245 {
2246    if (type == E_MOVE_EVENT_TYPE_MOTION_START)
2247      return _e_mod_move_quickpanel_cb_motion_start;
2248    else if (type == E_MOVE_EVENT_TYPE_MOTION_MOVE)
2249      return _e_mod_move_quickpanel_cb_motion_move;
2250    else if (type == E_MOVE_EVENT_TYPE_MOTION_END)
2251      return _e_mod_move_quickpanel_cb_motion_end;
2252    else
2253      return NULL;
2254 }
2255
2256 EINTERN Eina_Bool
2257 e_mod_move_quickpanel_visible_check(void)
2258 {
2259    E_Move_Border *mb;
2260    E_Zone        *zone;
2261    mb = e_mod_move_quickpanel_find();
2262    E_CHECK_RETURN(mb, EINA_FALSE);
2263    E_CHECK_RETURN(mb->visible, EINA_FALSE);
2264
2265    zone = mb->bd->zone;
2266    E_CHECK_RETURN(REGION_INSIDE_ZONE(mb, zone), EINA_FALSE);
2267
2268    return EINA_TRUE;
2269 }
2270
2271 EINTERN Eina_Bool
2272 e_mod_move_quickpanel_below_window_reset(void)
2273 {
2274    E_Move *m = e_mod_move_util_get();
2275    E_CHECK_RETURN(m, EINA_FALSE);
2276    return EINA_TRUE;
2277 }
2278
2279 EINTERN Eina_Bool
2280 e_mod_move_quickpanel_objs_clipper_add(E_Move_Border *mb)
2281 {
2282    E_CHECK_RETURN(mb, EINA_FALSE);
2283    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2284
2285    e_mod_move_bd_move_objs_clipper_add(mb);
2286    e_mod_move_bd_move_objs_clipper_move(mb, mb->x, mb->y);
2287    e_mod_move_bd_move_objs_clipper_resize(mb, mb->w, mb->h);
2288    e_mod_move_bd_move_objs_clipper_show(mb);
2289
2290    return EINA_TRUE;
2291 }
2292
2293 EINTERN Eina_Bool
2294 e_mod_move_quickpanel_objs_clipper_del(E_Move_Border *mb)
2295 {
2296    E_CHECK_RETURN(mb, EINA_FALSE);
2297    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2298
2299    e_mod_move_bd_move_objs_clipper_hide(mb);
2300    e_mod_move_bd_move_objs_clipper_del(mb);
2301    return EINA_TRUE;
2302 }
2303
2304 EINTERN Eina_Bool
2305 e_mod_move_quickpanel_objs_clipper_apply(E_Move_Border *mb, int x, int y)
2306 {
2307    int cx = 0, cy = 0, cw = 0, ch = 0; // clip_x, clip_y, clip_w, clip_h
2308    int angle = 0;
2309    E_Zone *zone = NULL;
2310
2311    E_CHECK_RETURN(mb, EINA_FALSE);
2312    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2313
2314    zone = mb->bd->zone;
2315    angle = mb->angle;
2316
2317    switch (angle)
2318      {
2319         case 90:
2320            cw = x;
2321            ch = mb->h;
2322            break;
2323
2324         case 180:
2325            cy = y;
2326            cw = mb->w;
2327            ch = zone->h - y;
2328            break;
2329
2330         case 270:
2331            cx = x;
2332            cw = zone->w - x;
2333            ch = mb->h;
2334            break;
2335
2336         case 0:
2337         default:
2338            cw = mb->w;
2339            ch = y;
2340            break;
2341      }
2342    e_mod_move_bd_move_objs_clipper_move(mb, cx, cy);
2343    e_mod_move_bd_move_objs_clipper_resize(mb, cw, ch);
2344
2345    return EINA_TRUE;
2346 }
2347
2348 EINTERN Eina_Bool
2349 e_mod_move_quickpanel_stage_init(E_Move_Border *mb)
2350 {
2351    E_Move *m = NULL;
2352    E_CHECK_RETURN(mb, EINA_FALSE);
2353    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2354
2355    m = mb->m;
2356
2357    // Composite mode set true
2358    e_mod_move_util_compositor_composite_mode_set(m, EINA_TRUE);
2359
2360    return EINA_TRUE;
2361 }
2362
2363 EINTERN Eina_Bool
2364 e_mod_move_quickpanel_stage_deinit(E_Move_Border *mb)
2365 {
2366    E_Move *m = NULL;
2367    E_CHECK_RETURN(mb, EINA_FALSE);
2368    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2369
2370    m = mb->m;
2371
2372    // Composite mode set false
2373    e_mod_move_util_compositor_composite_mode_set(m, EINA_FALSE);
2374    return EINA_TRUE;
2375 }
2376
2377 EINTERN Eina_Bool
2378 e_mod_move_quickpanel_angle_change_post_job(E_Move_Border *mb)
2379 {
2380    E_CHECK_RETURN(mb, EINA_FALSE);
2381    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2382
2383    if (e_mod_move_quickpanel_objs_animation_state_get(mb))
2384      return _e_mod_move_quickpanel_animation_change_with_angle(mb);
2385    else
2386      return _e_mod_move_quickpanel_fb_move_change_with_angle(mb);
2387 }
2388
2389 static Eina_Bool
2390 _e_mod_move_quickpanel_objs_outside_movable_pos_get(E_Move_Border *mb,
2391                                                     int           *x,
2392                                                     int           *y)
2393 // while quickpanel is animating,
2394 // if quickpanel angle changed, qp_objs move could fail. so qp_objs move again with changed angle.
2395 {
2396    E_Move *m = NULL;
2397    int ax = 0, ay = 0;
2398    int angle = 0;
2399    E_Zone *zone = NULL;
2400    E_Border *bd = NULL;
2401    E_CHECK_RETURN(x, EINA_FALSE);
2402    E_CHECK_RETURN(y, EINA_FALSE);
2403    E_CHECK_RETURN(mb, EINA_FALSE);
2404    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2405
2406    m = mb->m;
2407    E_CHECK_RETURN(m, EINA_FALSE);
2408    bd = mb->bd;
2409    E_CHECK_RETURN(bd, EINA_FALSE);
2410    zone = bd->zone;
2411    E_CHECK_RETURN(zone, EINA_FALSE);
2412    angle = mb->angle;
2413
2414    switch (angle)
2415      {
2416       case  90:
2417          if (m->qp_scroll_with_clipping)
2418            {
2419               ax = zone->x; ay = zone->y;
2420            }
2421          else
2422            {
2423               ax = mb->w * -1;
2424            }
2425          break;
2426       case 180:
2427          if (m->qp_scroll_with_clipping)
2428            {
2429               ax = zone->x + mb->w;
2430               ay = zone->y + mb->h;
2431            }
2432          else
2433            {
2434               ay =  zone->h;
2435            }
2436          break;
2437       case 270:
2438          if (m->qp_scroll_with_clipping)
2439            {
2440               ax = zone->x + mb->w;
2441               ay = zone->y + mb->h;
2442            }
2443          else
2444            {
2445               ax = zone->w;
2446            }
2447          break;
2448       case   0:
2449       default :
2450          if (m->qp_scroll_with_clipping)
2451            {
2452               ax = zone->x; ay = zone->y;
2453            }
2454          else
2455            {
2456               ay = mb->h * -1;;
2457            }
2458          break;
2459      }
2460    *x = ax;
2461    *y = ay;
2462    return EINA_TRUE;
2463 }
2464
2465 EINTERN Eina_Bool
2466 e_mod_move_quickpanel_window_input_region_change_post_job(E_Move_Border *mb)
2467 {
2468    E_Move *m = NULL;
2469    int hx = 0, hy = 0, hw = 0, hh = 0; // handle's x, y, w, h
2470
2471    E_CHECK_RETURN(mb, EINA_FALSE);
2472    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2473
2474    m = mb->m;
2475    E_CHECK_RETURN(m, EINA_FALSE);
2476
2477    if (m->qp_scroll_with_clipping)
2478      {
2479         if (e_mod_move_border_shape_input_rect_get(mb, &hx, &hy, &hw, &hh))
2480           _e_mod_move_quickpanel_handle_objs_size_update(mb, hw, hh);
2481      }
2482
2483    return EINA_TRUE;
2484 }
2485
2486 EINTERN Eina_Bool
2487 e_mod_move_quickpanel_anim_state_send(E_Move_Border *mb,
2488                                       Eina_Bool      state)
2489 {
2490    long d[5] = {0L, 0L, 0L, 0L, 0L};
2491    Ecore_X_Window win;
2492    E_CHECK_RETURN(mb, EINA_FALSE);
2493    E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
2494
2495    win = e_mod_move_util_client_xid_get(mb);
2496    E_CHECK_RETURN(win, 0);
2497
2498    if (state) d[0] = 1L;
2499    else d[0] = 0L;
2500
2501    ecore_x_client_message32_send
2502      (win, ATOM_MV_QUICKPANEL_STATE,
2503      ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
2504      d[0], d[1], d[2], d[3], d[4]);
2505
2506    return EINA_TRUE;
2507 }