src/lib/elm_transit.c

   1 #include <Elementary.h>
   2
   3 /**
   4  *
   5  * @defgroup Transit Transit
   6  * @ingroup Elementary
   7  *
   8  * Transit is designed to set the various effects for the Evas_Object such like translation,
   9  * rotation, etc. For using Effects, Create transit and insert the some of effects which are
  10  * interested. Each effects has the type of Elm_Effect and those can be inserted into transit.
  11  * Once effects are inserted into transit, transit will manage those effects.(ex) deleting).
  12 */
  13 struct _transit
  14 {
  15    Evas_Object *parent;
  16    Elm_Animator *animator;
  17    Eina_List *effect_list;
  18    Evas_Object *block_rect;
  19    void (*completion_op) (void *data, Elm_Transit *transit);
  20    void *completion_arg;
  21    Eina_Bool reserved_del:1;
  22 };
  23
  24 struct _effect
  25 {
  26    void (*animation_op) (void *data, Elm_Animator *animator, double frame);
  27    void (*begin_op) (void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt);
  28    void (*end_op) (void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt);
  29    void (*del_op) (void* data);
  30    unsigned int shared_cnt;
  31    void *user_data;
  32 };
  33
  34 static Evas_Object *_create_block_rect(Evas_Object *parent);
  35 static void _transit_animate_cb(void *data, Elm_Animator *animator,
  36                                 double frame);
  37 static void _transit_fx_begin(Elm_Transit *transit);
  38 static void _transit_fx_end(Elm_Transit *transit);
  39 static void _transit_complete_cb(void *data);
  40 static void _transit_fx_del(Elm_Effect *effect);
  41 //static void _transit_parent_del(void *data);
  42
  43 /*
  44 static void
  45 _animator_parent_del(void *data)
  46 {
  47         Elm_Transit *transit = data;
  48         elm_transit_del(data);
  49 }
  50 */
  51
  52 static Evas_Object *
  53 _create_block_rect(Evas_Object *parent)
  54 {
  55    Evas_Object *rect;
  56
  57    Evas_Coord w, h;
  58
  59    rect = evas_object_rectangle_add(evas_object_evas_get(parent));
  60    evas_output_size_get(evas_object_evas_get(parent), &w, &h);
  61    evas_object_resize(rect, w, h);
  62    evas_object_color_set(rect, 0, 0, 0, 0);
  63    return rect;
  64 }
  65
  66 static void
  67 _transit_animate_cb(void *data, Elm_Animator *animator, double frame)
  68 {
  69    Eina_List *elist;
  70
  71    Elm_Effect *effect;
  72
  73    Elm_Transit *transit = data;
  74
  75    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
  76    {
  77       effect->animation_op(effect->user_data, animator, frame);
  78    }
  79 }
  80
  81 static void
  82 _transit_fx_begin(Elm_Transit *transit)
  83 {
  84    Eina_List *elist;
  85
  86    Elm_Effect *effect;
  87
  88    Eina_Bool auto_reverse;
  89
  90    unsigned int repeat_cnt;
  91
  92    auto_reverse = elm_animator_auto_reverse_get(transit->animator);
  93    repeat_cnt = elm_animator_repeat_get(transit->animator);
  94
  95    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
  96    {
  97       if (effect->begin_op)
  98          effect->begin_op(effect->user_data, auto_reverse, repeat_cnt);
  99    }
 100 }
 101
 102 static void
 103 _transit_fx_end(Elm_Transit *transit)
 104 {
 105    Eina_List *elist;
 106
 107    Elm_Effect *effect;
 108
 109    Eina_Bool auto_reverse;
 110
 111    unsigned int repeat_cnt;
 112
 113    auto_reverse = elm_animator_auto_reverse_get(transit->animator);
 114    repeat_cnt = elm_animator_repeat_get(transit->animator);
 115
 116    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
 117    {
 118       if (effect->end_op)
 119          effect->end_op(effect->user_data, auto_reverse, repeat_cnt);
 120    }
 121 }
 122
 123 static void
 124 _transit_complete_cb(void *data)
 125 {
 126    Elm_Transit *transit = (Elm_Transit *) data;
 127
 128    evas_render(evas_object_evas_get(transit->parent));
 129
 130    _transit_fx_end(transit);
 131
 132    if (transit->block_rect)
 133       evas_object_hide(transit->block_rect);
 134
 135    if (transit->completion_op)
 136       transit->completion_op(transit->completion_arg, transit);
 137
 138    if (transit->reserved_del)
 139      {
 140         transit->reserved_del = EINA_FALSE;
 141         elm_transit_del(transit);
 142      }
 143 }
 144
 145 static void
 146 _transit_fx_del(Elm_Effect *effect)
 147 {
 148    if (!effect)
 149       return;
 150
 151    --effect->shared_cnt;
 152
 153    if (effect->shared_cnt > 0)
 154       return;
 155
 156    if(effect->del_op)
 157            (*effect->del_op)(effect->user_data);
 158
 159    if (effect->user_data)
 160       free(effect->user_data);
 161    free(effect);
 162 }
 163
 164 /**
 165  * Set the event blocked when transit is operating.
 166  *
 167  * @param transit Transit object
 168  * @param disabled Disable or enable
 169  *
 170  * @ingroup Transit
 171  */
 172 EAPI void
 173 elm_transit_event_block_disabled_set(Elm_Transit *transit, Eina_Bool disabled)
 174 {
 175    if (!transit)
 176       return;
 177
 178    if (disabled)
 179      {
 180         if (transit->block_rect)
 181           {
 182              evas_object_del(transit->block_rect);
 183              transit->block_rect = NULL;
 184           }
 185      }
 186    else
 187      {
 188         if (transit->block_rect == NULL)
 189            transit->block_rect = _create_block_rect(transit->parent);
 190      }
 191 }
 192
 193 /**
 194  * Get the value of event blockd status.
 195  *
 196  * @param transit Transit
 197  * @return EINA_TRUE, when event block is disabled
 198  *
 199  * @ingroup Transit
 200  */
 201 EAPI Eina_Bool
 202 elm_transit_event_block_disabled_get(Elm_Transit *transit)
 203 {
 204    if (!transit)
 205       return EINA_FALSE;
 206    return transit->block_rect ? EINA_TRUE : EINA_FALSE;
 207 }
 208
 209 /**
 210  * Remove effect from transit.
 211  *
 212  * @param transit       Transit
 213  * @param effect Effect to be removed
 214  * @return EINA_TRUE, if the effect is removed
 215  * @warning If removed effect does not inserted in any transit, it will be deleted.
 216  *
 217  * @ingroup Transit
 218  */
 219 EAPI Eina_Bool
 220 elm_transit_fx_remove(Elm_Transit *transit, Elm_Effect *effect)
 221 {
 222    Eina_List *elist;
 223
 224    Elm_Effect *_effect;
 225
 226    if (!transit)
 227       return EINA_FALSE;
 228
 229    EINA_LIST_FOREACH(transit->effect_list, elist, _effect)
 230    {
 231       if (_effect == effect)
 232         {
 233            transit->effect_list =
 234               eina_list_remove(transit->effect_list, _effect);
 235            _transit_fx_del(_effect);
 236            return EINA_TRUE;
 237         }
 238    }
 239    return EINA_FALSE;
 240 }
 241
 242 /**
 243  * Remove all current inserted effects.
 244  *
 245  * @param transit       Transit
 246  *
 247  * @ingroup Transit
 248  */
 249 EAPI void
 250 elm_transit_fx_clear(Elm_Transit *transit)
 251 {
 252    Eina_List *elist;
 253
 254    Elm_Effect *effect;
 255
 256    if (!transit)
 257       return;
 258
 259    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
 260    {
 261       transit->effect_list = eina_list_remove(transit->effect_list, effect);
 262       _transit_fx_del(effect);
 263    }
 264 }
 265
 266 /**
 267  * Get the list of current inseted effects.
 268  *
 269  * @param transit       Transit
 270  * @return Effect list
 271  *
 272  * @ingroup Transit
 273  */
 274 EAPI const Eina_List *
 275 elm_transit_fx_get(Elm_Transit *transit)
 276 {
 277    if (!transit)
 278       return NULL;
 279    return transit->effect_list;
 280 }
 281
 282 /**
 283  * Set the user-callback function when the transit operation is done.
 284  *
 285  * @param transit       Transit
 286  * @param op Callback function pointer
 287  * @param data Callback funtion user data
 288  *
 289  * @ingroup Transit
 290  */
 291 EAPI void
 292 elm_transit_completion_callback_set(Elm_Transit *transit,
 293                                     void (*op) (void *data,
 294                                                 Elm_Transit *transit),
 295                                     void *data)
 296 {
 297    if (!transit)
 298       return;
 299    transit->completion_op = op;
 300    transit->completion_arg = data;
 301 }
 302
 303 /**
 304  * Delete transit.
 305  *
 306  * @param transit       Transit to be deleted
 307  *
 308  * @ingroup Transit
 309  */
 310 EAPI void
 311 elm_transit_del(Elm_Transit *transit)
 312 {
 313    if (!transit)
 314       return;
 315    if (elm_animator_operating_get(transit->animator))
 316      {
 317         transit->reserved_del = EINA_TRUE;
 318         return;
 319      }
 320
 321    if (transit->block_rect)
 322       evas_object_del(transit->block_rect);
 323
 324    elm_animator_del(transit->animator);
 325    elm_transit_fx_clear(transit);
 326
 327 //      if(transit->parent)
 328 //      {
 329 //              evas_object_event_callback_del(transit->parent, EVAS_CALLBACK_DEL, _transit_parent_del);
 330 //      }
 331
 332    free(transit);
 333 }
 334
 335 /**
 336  * Set the transit animation acceleration style.
 337  *
 338  * @param transit       Transit
 339  * @param cs Curve style(Please refer elm_animator_curve_style_set)
 340  *
 341  * @ingroup Transit
 342  */
 343 EAPI void
 344 elm_transit_curve_style_set(Elm_Transit *transit, Elm_Animator_Curve_Style cs)
 345 {
 346    if (!transit)
 347       return;
 348    elm_animator_curve_style_set(transit->animator, cs);
 349 }
 350
 351
 352 /**
 353  * Add new transit.
 354  *
 355  * @param parent Parent object
 356  * @return transit
 357  *
 358  * @ingroup Transit
 359  */
 360 EAPI Elm_Transit *
 361 elm_transit_add(Evas_Object *parent)
 362 {
 363    Elm_Transit *transit = calloc(1, sizeof(Elm_Transit));
 364
 365    if (!transit)
 366       return NULL;
 367
 368    transit->animator = elm_animator_add(parent);
 369
 370    if (!transit->animator)
 371      {
 372         free(transit);
 373         return NULL;
 374      }
 375
 376    transit->parent = parent;
 377    elm_animator_operation_callback_set(transit->animator, _transit_animate_cb,
 378                                        transit);
 379    elm_animator_completion_callback_set(transit->animator, _transit_complete_cb,
 380                                         transit);
 381    elm_transit_event_block_disabled_set(transit, EINA_FALSE);
 382 /*
 383         if(parent)
 384         {
 385                 evas_object_event_callback_add(parent, EVAS_CALLBACK_DEL, _transit_parent_del,
 386                                                          transit);
 387         }
 388 */
 389    return transit;
 390 }
 391
 392 /**
 393  * Set reverse effect automatically.
 394  *
 395  * @param transit Transit
 396  * @param reverse EINA_TRUE is reverse.
 397  *
 398  * @ingroup Transit
 399  */
 400 EAPI void
 401 elm_transit_auto_reverse_set(Elm_Transit *transit, Eina_Bool reverse)
 402 {
 403    if (!transit)
 404       return;
 405    elm_animator_auto_reverse_set(transit->animator, reverse);
 406 }
 407
 408 /**
 409  * Insert an effect into the transit.
 410  *
 411  * @param transit Transit
 412  * @param effect Effect to be inserted
 413  * @return EINA_TRUE is success
 414  *
 415  * @ingroup Transit
 416  */
 417 EAPI Eina_Bool
 418 elm_transit_fx_insert(Elm_Transit *transit, Elm_Effect *effect)
 419 {
 420    Eina_List *elist;
 421
 422    Elm_Effect *_effect;
 423
 424    if (!transit)
 425       return EINA_FALSE;
 426
 427    EINA_LIST_FOREACH(transit->effect_list, elist, _effect)
 428    {
 429       if (_effect == effect)
 430          return EINA_FALSE;
 431    }
 432
 433    ++effect->shared_cnt;
 434    transit->effect_list = eina_list_append(transit->effect_list, effect);
 435
 436    return EINA_TRUE;
 437 }
 438
 439 /**
 440  * Set the transit repeat count. Effect will be repeated by repeat count.
 441  *
 442  * @param transit Transit
 443  * @param repeat Repeat count
 444  *
 445  * @ingroup Transit
 446  */
 447 EAPI void
 448 elm_transit_repeat_set(Elm_Transit *transit, unsigned int repeat)
 449 {
 450    if (!transit)
 451       return;
 452    elm_animator_repeat_set(transit->animator, repeat);
 453 }
 454
 455 /**
 456  * Stop the current transit, if the transit is operating.
 457  *
 458  * @param transit Transit
 459  *
 460  * @ingroup Transit
 461  */
 462 EAPI void
 463 elm_transit_stop(Elm_Transit *transit)
 464 {
 465    if (!transit)
 466       return;
 467    elm_animator_stop(transit->animator);
 468 }
 469
 470 /**
 471  * Run the all the inserted effects.
 472  *
 473  * @param transit Transit
 474  * @param duration Transit time in seconds
 475  *
 476  * @ingroup Transit
 477  */
 478 EAPI void
 479 elm_transit_run(Elm_Transit *transit, double duration)
 480 {
 481    if (!transit)
 482       return;
 483    _transit_fx_begin(transit);
 484    elm_animator_duration_set(transit->animator, duration);
 485
 486    //Block to Top
 487    if (transit->block_rect)
 488       evas_object_show(transit->block_rect);
 489
 490    elm_animator_animate(transit->animator);
 491
 492    //If failed to animate.
 493    if (!elm_animator_operating_get(transit->animator))
 494      {
 495         if (transit->block_rect)
 496            evas_object_hide(transit->block_rect);
 497         _transit_fx_end(transit);
 498      }
 499 }
 500
 501 /**
 502  * Pause the transit
 503  *
 504  * @param  transit Transit
 505  *
 506  * @ingroup Transit
 507  */
 508 EAPI void
 509 elm_transit_pause(Elm_Transit *transit)
 510 {
 511         if(!transit)
 512                 return;
 513
 514         elm_animator_pause(transit->animator);
 515 }
 516
 517 /**
 518  * Resume the transit
 519  *
 520  * @param  transit Transit
 521  *
 522  * @ingroup Transit
 523  */
 524 EAPI void
 525 elm_transit_resume(Elm_Transit *transit)
 526 {
 527         if(!transit)
 528                 return;
 529
 530         elm_animator_resume(transit->animator);
 531 }
 532
 533
 534
 535 /////////////////////////////////////////////////////////////////////////////////////
 536 //Resizing FX
 537 /////////////////////////////////////////////////////////////////////////////////////
 538 typedef struct _resizing Elm_Fx_Resizing;
 539 static void _elm_fx_resizing_op(void *data, Elm_Animator *animator,
 540                                 double frame);
 541 static void _elm_fx_resizing_begin(void *data, Eina_Bool auto_reverse,
 542                                 unsigned int repeat_cnt);
 543
 544 struct _resizing
 545 {
 546    Evas_Object *obj;
 547    struct _size
 548    {
 549       Evas_Coord w, h;
 550    } from, to;
 551 };
 552
 553 static void
 554 _elm_fx_resizing_begin(void *data, Eina_Bool auto_reverse,
 555                        unsigned int repeat_cnt)
 556 {
 557    Elm_Fx_Resizing *resizing = data;
 558
 559    evas_object_show(resizing->obj);
 560    evas_object_resize(resizing->obj, resizing->from.w, resizing->from.h);
 561 }
 562
 563 static void
 564 _elm_fx_resizing_op(void *data, Elm_Animator *animator, double frame)
 565 {
 566    Evas_Coord w, h;
 567
 568    Elm_Fx_Resizing *resizing = data;
 569
 570    w = resizing->from.w + (Evas_Coord) ((float)resizing->to.h * (float)frame);
 571    h = resizing->from.h + (Evas_Coord) ((float)resizing->to.w * (float)frame);
 572    evas_object_resize(resizing->obj, w, h);
 573 }
 574
 575 /**
 576  * Add Resizing effect.
 577  *
 578  * @param obj Evas_Object that effect is applying to
 579  * @param from_w Object width size when effect begins
 580  * @param from_h Object height size when effect begins
 581  * @param to_w Object width size when effect ends
 582  * @param to_h Object height size when effect ends
 583  * @return Resizing effect
 584  *
 585  * @ingroup Transit
 586  */
 587 EAPI Elm_Effect *
 588 elm_fx_resizing_add(Evas_Object *obj, Evas_Coord from_w, Evas_Coord from_h,
 589                     Evas_Coord to_w, Evas_Coord to_h)
 590 {
 591    Elm_Effect *effect;
 592
 593    Elm_Fx_Resizing *resizing;
 594
 595    if (!obj)
 596       return NULL;
 597
 598    effect = calloc(1, sizeof(Elm_Effect));
 599    if (!effect)
 600       return NULL;
 601
 602    resizing = calloc(1, sizeof(Elm_Fx_Resizing));
 603    if (!resizing)
 604      {
 605         free(effect);
 606         return NULL;
 607      }
 608
 609    resizing->obj = obj;
 610    resizing->from.w = from_w;
 611    resizing->from.h = from_h;
 612    resizing->to.w = to_w - from_w;
 613    resizing->to.h = to_h - from_h;
 614
 615    effect->begin_op = _elm_fx_resizing_begin;
 616    effect->animation_op = _elm_fx_resizing_op;
 617    effect->user_data = resizing;
 618
 619    return effect;
 620 }
 621
 622 /////////////////////////////////////////////////////////////////////////////////////
 623 //Translation FX
 624 /////////////////////////////////////////////////////////////////////////////////////
 625 typedef struct _translation Elm_Fx_Translation;
 626 static void _elm_fx_translation_op(void *data, Elm_Animator *animator,
 627                                 double frame);
 628 static void _elm_fx_translation_begin(void *data, Eina_Bool auto_reverse,
 629                                 unsigned int repeat_cnt);
 630 static void _elm_fx_translation_end(void *data, Eina_Bool auto_reverse,
 631                                 unsigned int repeat_cnt);
 632
 633 struct _translation
 634 {
 635    Evas_Object *obj;
 636    struct _point
 637    {
 638       Evas_Coord x, y;
 639    } from, to;
 640 };
 641
 642 static void
 643 _elm_fx_translation_begin(void *data, Eina_Bool auto_reverse,
 644                           unsigned int repeat_cnt)
 645 {
 646    Elm_Fx_Translation *translation = data;
 647
 648    evas_object_show(translation->obj);
 649    evas_object_move(translation->obj, translation->from.x, translation->from.y);
 650 }
 651
 652 static void
 653 _elm_fx_translation_end(void *data, Eina_Bool auto_reverse,
 654                         unsigned int repeat_cnt)
 655 {
 656    Elm_Fx_Translation *translation = data;
 657
 658    evas_object_move(translation->obj, translation->from.x + translation->to.x,
 659                     translation->from.y + translation->to.y);
 660 }
 661
 662 static void
 663 _elm_fx_translation_op(void *data, Elm_Animator *animator, double frame)
 664 {
 665    Evas_Coord x, y;
 666
 667    Elm_Fx_Translation *translation = data;
 668
 669    x = translation->from.x +
 670       (Evas_Coord) ((float)translation->to.x * (float)frame);
 671    y = translation->from.y +
 672       (Evas_Coord) ((float)translation->to.y * (float)frame);
 673    evas_object_move(translation->obj, x, y);
 674 }
 675
 676 /**
 677  * Add Translation effect.
 678  *
 679  * @param obj Evas_Object that effect is applying to
 680  * @param from_x Position X when effect begins
 681  * @param from_y Position Y when effect begins
 682  * @param to_x Position X when effect ends
 683  * @param to_y Position Y when effect ends
 684  * @return Translation effect
 685  *
 686  * @ingroup Transit
 687  */
 688 EAPI Elm_Effect *
 689 elm_fx_translation_add(Evas_Object *obj, Evas_Coord from_x, Evas_Coord from_y,
 690                        Evas_Coord to_x, Evas_Coord to_y)
 691 {
 692    Elm_Effect *effect;
 693
 694    Elm_Fx_Translation *translation;
 695
 696    if (!obj)
 697       return NULL;
 698
 699    effect = calloc(1, sizeof(Elm_Effect));
 700    if (!effect)
 701       return NULL;
 702
 703    translation = calloc(1, sizeof(Elm_Fx_Translation));
 704
 705    if (!translation)
 706      {
 707         free(effect);
 708         return NULL;
 709      }
 710
 711    translation->obj = obj;
 712    translation->from.x = from_x;
 713    translation->from.y = from_y;
 714    translation->to.x = to_x - from_x;
 715    translation->to.y = to_y - from_y;
 716
 717    effect->begin_op = _elm_fx_translation_begin;
 718    effect->end_op = _elm_fx_translation_end;
 719    effect->animation_op = _elm_fx_translation_op;
 720    effect->user_data = translation;
 721
 722    return effect;
 723 }
 724
 725 /////////////////////////////////////////////////////////////////////////////////////
 726 //Zoom FX
 727 /////////////////////////////////////////////////////////////////////////////////////
 728 typedef struct _zoom Elm_Fx_Zoom;
 729 static void _elm_fx_zoom_op(void *data, Elm_Animator * animator,
 730                                 double frame);
 731 static void _elm_fx_zoom_begin(void *data, Eina_Bool reverse,
 732                                 unsigned int repeat);
 733 static void _elm_fx_zoom_end(void *data, Eina_Bool reverse,
 734                                 unsigned int repeat);
 735
 736 struct _zoom
 737 {
 738    Evas_Object *obj;
 739    float from, to;
 740 };
 741
 742 static void
 743 _elm_fx_zoom_begin(void *data, Eina_Bool reverse, unsigned int repeat)
 744 {
 745    Elm_Fx_Zoom *zoom = data;
 746
 747    evas_object_show(zoom->obj);
 748    _elm_fx_zoom_op(data, NULL, 0);
 749 }
 750
 751 static void
 752 _elm_fx_zoom_end(void *data, Eina_Bool reverse, unsigned int repeat)
 753 {
 754    Elm_Fx_Zoom *zoom = data;
 755
 756    evas_object_map_enable_set(zoom->obj, EINA_FALSE);
 757 }
 758
 759 static void
 760 _elm_fx_zoom_op(void *data, Elm_Animator *animator, double frame)
 761 {
 762    Elm_Fx_Zoom *zoom;
 763
 764    Evas_Map *map;
 765
 766    Evas_Coord x, y, w, h;
 767
 768    map = evas_map_new(4);
 769    if (!map)
 770       return;
 771
 772    zoom = data;
 773    evas_object_geometry_get(zoom->obj, &x, &y, &w, &h);
 774    evas_map_smooth_set(map, EINA_TRUE);
 775    evas_map_util_points_populate_from_object_full(map, zoom->obj,
 776                                                   zoom->from +
 777                                                   (frame * zoom->to));
 778    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, 10000);
 779    evas_object_map_set(zoom->obj, map);
 780    evas_object_map_enable_set(zoom->obj, EINA_TRUE);
 781    evas_map_free(map);
 782 }
 783
 784 /**
 785  * Add Zoom effect.
 786  *
 787  * @param obj Evas_Object that effect is applying to
 788  * @param from_rate Scale rate when effect begins (1 is current rate)
 789  * @param to_rate Scale rate when effect ends
 790  * @return Zoom effect
 791  *
 792  * @ingroup Transit
 793  */
 794 EAPI Elm_Effect *
 795 elm_fx_zoom_add(Evas_Object *obj, float from_rate, float to_rate)
 796 {
 797    Elm_Effect *effect;
 798
 799    Elm_Fx_Zoom *zoom;
 800
 801    if (!obj)
 802       return NULL;
 803
 804    effect = calloc(1, sizeof(Elm_Effect));
 805    if (!effect)
 806       return NULL;
 807
 808    zoom = calloc(1, sizeof(Elm_Fx_Zoom));
 809    if (!zoom)
 810      {
 811         free(effect);
 812         return NULL;
 813      }
 814
 815    zoom->obj = obj;
 816    zoom->from = (10000 - (from_rate * 10000)) * (1 / from_rate);
 817    zoom->to = ((10000 - (to_rate * 10000)) * (1 / to_rate)) - zoom->from;
 818    effect->begin_op = _elm_fx_zoom_begin;
 819    effect->end_op = _elm_fx_zoom_end;
 820    effect->animation_op = _elm_fx_zoom_op;
 821    effect->user_data = zoom;
 822
 823    return effect;
 824
 825 }
 826
 827 /////////////////////////////////////////////////////////////////////////////////////
 828 //Flip FX
 829 /////////////////////////////////////////////////////////////////////////////////////
 830 typedef struct _flip Elm_Fx_Flip;
 831 static void _elm_fx_flip_op(void *data, Elm_Animator *animator,
 832                                 double frame);
 833 static void _elm_fx_flip_end(void *data, Eina_Bool auto_reverse,
 834                                 unsigned int repeat_cnt);
 835
 836 struct _flip
 837 {
 838    Evas_Object *front;
 839    Evas_Object *back;
 840    Elm_Fx_Flip_Axis axis;
 841    Eina_Bool cw:1;
 842 };
 843
 844 static void
 845 _elm_fx_flip_end(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
 846 {
 847    Elm_Fx_Flip *flip = data;
 848
 849    evas_object_map_enable_set(flip->front, EINA_FALSE);
 850    evas_object_map_enable_set(flip->back, EINA_FALSE);
 851 }
 852
 853 static void
 854 _elm_fx_flip_op(void *data, Elm_Animator *animator, double frame)
 855 {
 856    Elm_Fx_Flip *flip;
 857
 858    Evas_Map *map;
 859
 860    float degree;
 861
 862    Evas_Object *obj;
 863
 864    Evas_Coord x, y, w, h;
 865
 866    map = evas_map_new(4);
 867    if (!map)
 868       return;
 869
 870    flip = data;
 871
 872    if (flip->cw)
 873       degree = (float)(frame * 180);
 874    else
 875       degree = (float)(frame * -180);
 876
 877    if (degree < 90 && degree > -90)
 878      {
 879         obj = flip->front;
 880         evas_object_hide(flip->back);
 881         evas_object_show(flip->front);
 882      }
 883    else
 884      {
 885         obj = flip->back;
 886         evas_object_hide(flip->front);
 887         evas_object_show(flip->back);
 888      }
 889
 890    evas_map_smooth_set(map, EINA_TRUE);
 891    evas_map_util_points_populate_from_object_full(map, obj, 0);
 892    evas_object_geometry_get(obj, &x, &y, &w, &h);
 893    Evas_Coord half_w = (w / 2);
 894
 895    Evas_Coord half_h = (h / 2);
 896
 897    if (flip->axis == ELM_FX_FLIP_AXIS_Y)
 898      {
 899         if ((degree >= 90) || (degree <= -90))
 900           {
 901              evas_map_point_image_uv_set(map, 0, w, 0);
 902              evas_map_point_image_uv_set(map, 1, 0, 0);
 903              evas_map_point_image_uv_set(map, 2, 0, h);
 904              evas_map_point_image_uv_set(map, 3, w, h);
 905           }
 906         evas_map_util_3d_rotate(map, 0, degree, 0, x + half_w, y + half_h, 0);
 907      }
 908    else
 909      {
 910         if ((degree >= 90) || (degree <= -90))
 911           {
 912              evas_map_point_image_uv_set(map, 0, 0, h);
 913              evas_map_point_image_uv_set(map, 1, w, h);
 914              evas_map_point_image_uv_set(map, 2, w, 0);
 915              evas_map_point_image_uv_set(map, 3, 0, 0);
 916           }
 917         evas_map_util_3d_rotate(map, degree, 0, 0, x + half_w, y + half_h, 0);
 918      }
 919    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
 920    evas_object_map_enable_set(flip->front, EINA_TRUE);
 921    evas_object_map_enable_set(flip->back, EINA_TRUE);
 922    evas_object_map_set(obj, map);
 923    evas_map_free(map);
 924 }
 925
 926 /**
 927  * Add Flip effect.
 928  *
 929  * @param front Front surface object
 930  * @param back Back surface object
 931  * @param axis Flipping Axis(X or Y)
 932  * @param cw Flipping Direction. EINA_TRUE is clock-wise
 933  * @return Flip effect
 934  *
 935  * @ingroup Transit
 936  */
 937 EAPI Elm_Effect *
 938 elm_fx_flip_add(Evas_Object *front, Evas_Object *back, Elm_Fx_Flip_Axis axis,
 939                 Eina_Bool cw)
 940 {
 941    Elm_Effect *effect;
 942
 943    Elm_Fx_Flip *flip;
 944
 945    if ((!front) || (!back))
 946       return NULL;
 947
 948    effect = calloc(1, sizeof(Elm_Effect));
 949    if (!effect)
 950       return NULL;
 951
 952    flip = calloc(1, sizeof(Elm_Fx_Flip));
 953
 954    if (!flip)
 955      {
 956         free(effect);
 957         return NULL;
 958      }
 959
 960    flip->front = front;
 961    flip->back = back;
 962    flip->cw = cw;
 963    flip->axis = axis;
 964    effect->end_op = _elm_fx_flip_end;
 965    effect->animation_op = _elm_fx_flip_op;
 966    effect->user_data = flip;
 967
 968    return effect;
 969 }
 970
 971 /////////////////////////////////////////////////////////////////////////////////////
 972 //ResizableFlip FX
 973 /////////////////////////////////////////////////////////////////////////////////////
 974 typedef struct _resizable_flip Elm_Fx_ResizableFlip;
 975 static void _elm_fx_resizable_flip_begin(void *data, Eina_Bool reverse,
 976                                 unsigned int repeat);
 977 static void _elm_fx_resizable_flip_end(void *data, Eina_Bool auto_reverse,
 978                                 unsigned int repeat_cnt);
 979 static void _elm_fx_resizable_flip_op(void *data, Elm_Animator *animator,
 980                                       double frame);
 981 static void _set_image_uv_by_axis_y(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
 982                                 float degree);
 983 static void _set_image_uv_by_axis_x(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
 984                                 float degree);
 985
 986 struct _resizable_flip
 987 {
 988    Evas_Object *front;
 989    Evas_Object *back;
 990    Elm_Fx_Flip_Axis axis;
 991    struct _vector2d
 992    {
 993       float x, y;
 994    } from_pos, from_size, to_pos, to_size;
 995    Eina_Bool cw:1;
 996 };
 997
 998 static void
 999 _elm_fx_resizable_flip_begin(void *data, Eina_Bool reverse, unsigned int repeat)
1000 {
1001    Elm_Fx_ResizableFlip *resizable_flip = data;
1002
1003    evas_object_show(resizable_flip->front);
1004    _elm_fx_resizable_flip_op(data, NULL, 0);
1005 }
1006
1007 static void
1008 _elm_fx_resizable_flip_end(void *data, Eina_Bool auto_reverse,
1009                            unsigned int repeat_cnt)
1010 {
1011    Elm_Fx_ResizableFlip *resizable_flip = data;
1012
1013    evas_object_map_enable_set(resizable_flip->front, EINA_FALSE);
1014    evas_object_map_enable_set(resizable_flip->back, EINA_FALSE);
1015 }
1016
1017 static void
1018 _set_image_uv_by_axis_y(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
1019                         float degree)
1020 {
1021    if ((degree >= 90) || (degree <= -90))
1022      {
1023         evas_map_point_image_uv_set(map, 0,
1024                                     (flip->from_size.x * 2) + flip->to_size.x,
1025                                     0);
1026         evas_map_point_image_uv_set(map, 1, 0, 0);
1027         evas_map_point_image_uv_set(map, 2, 0,
1028                                     (flip->from_size.y * 2) + flip->to_size.y);
1029         evas_map_point_image_uv_set(map, 3,
1030                                     (flip->from_size.x * 2) + flip->to_size.x,
1031                                     (flip->from_size.y * 2) + flip->to_size.y);
1032      }
1033    else
1034      {
1035         evas_map_point_image_uv_set(map, 0, 0, 0);
1036         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1037         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1038                                     flip->from_size.y);
1039         evas_map_point_image_uv_set(map, 3, 0, flip->to_size.y);
1040      }
1041 }
1042
1043 static void
1044 _set_image_uv_by_axis_x(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
1045                         float degree)
1046 {
1047    if ((degree >= 90) || (degree <= -90))
1048      {
1049         evas_map_point_image_uv_set(map, 0, 0,
1050                                     (flip->from_size.y * 2) + flip->to_size.y);
1051         evas_map_point_image_uv_set(map, 1,
1052                                     (flip->from_size.x * 2) + flip->to_size.x,
1053                                     (flip->from_size.y * 2) + flip->to_size.y);
1054         evas_map_point_image_uv_set(map, 2,
1055                                     (flip->from_size.x * 2) + flip->to_size.x,
1056                                     0);
1057         evas_map_point_image_uv_set(map, 3, 0, 0);
1058      }
1059    else
1060      {
1061         evas_map_point_image_uv_set(map, 0, 0, 0);
1062         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1063         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1064                                     flip->from_size.y);
1065         evas_map_point_image_uv_set(map, 3, 0, flip->to_size.y);
1066      }
1067 }
1068
1069 static void
1070 _elm_fx_resizable_flip_op(void *data, Elm_Animator *animator, double frame)
1071 {
1072    Elm_Fx_ResizableFlip *resizable_flip;
1073
1074    Evas_Map *map;
1075
1076    float degree;
1077
1078    Evas_Object *obj;
1079
1080    float x, y, w, h;
1081
1082    Evas_Coord half_w, half_h;
1083
1084    map = evas_map_new(4);
1085    if (!map)
1086       return;
1087
1088    resizable_flip = data;
1089
1090    if (resizable_flip->cw)
1091       degree = (float)(frame * 180);
1092    else
1093       degree = (float)(frame * -180);
1094
1095    if ((degree < 90) && (degree > -90))
1096      {
1097         obj = resizable_flip->front;
1098         evas_object_hide(resizable_flip->back);
1099         evas_object_show(resizable_flip->front);
1100      }
1101    else
1102      {
1103         obj = resizable_flip->back;
1104         evas_object_hide(resizable_flip->front);
1105         evas_object_show(resizable_flip->back);
1106      }
1107
1108    evas_map_smooth_set(map, EINA_TRUE);
1109
1110    x = resizable_flip->from_pos.x + (resizable_flip->to_pos.x * frame);
1111    y = resizable_flip->from_pos.y + (resizable_flip->to_pos.y * frame);
1112    w = resizable_flip->from_size.x + (resizable_flip->to_size.x * frame);
1113    h = resizable_flip->from_size.y + (resizable_flip->to_size.y * frame);
1114    evas_map_point_coord_set(map, 0, x, y, 0);
1115    evas_map_point_coord_set(map, 1, x + w, y, 0);
1116    evas_map_point_coord_set(map, 2, x + w, y + h, 0);
1117    evas_map_point_coord_set(map, 3, x, y + h, 0);
1118
1119    half_w = (Evas_Coord) (w / 2);
1120    half_h = (Evas_Coord) (h / 2);
1121
1122    if (resizable_flip->axis == ELM_FX_FLIP_AXIS_Y)
1123      {
1124         _set_image_uv_by_axis_y(map, resizable_flip, degree);
1125         evas_map_util_3d_rotate(map, 0, degree, 0, x + half_w, y + half_h, 0);
1126      }
1127    else
1128      {
1129         _set_image_uv_by_axis_x(map, resizable_flip, degree);
1130         evas_map_util_3d_rotate(map, degree, 0, 0, x + half_w, y + half_h, 0);
1131      }
1132
1133    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
1134    evas_object_map_enable_set(resizable_flip->front, EINA_TRUE);
1135    evas_object_map_enable_set(resizable_flip->back, EINA_TRUE);
1136    evas_object_map_set(obj, map);
1137    evas_map_free(map);
1138 }
1139
1140 /**
1141  * Add ResizbleFlip effect. the size of each surface objects are interpolated automatically.
1142  *
1143  * @param front Front surface object
1144  * @param back Back surface object
1145  * @param axis Flipping Axis.(X or Y)
1146  * @param cw Flipping Direction. EINA_TRUE is clock-wise
1147  * @return Flip effect
1148  *
1149  * @ingroup Transit
1150  */
1151 EAPI Elm_Effect *
1152 elm_fx_resizable_flip_add(Evas_Object *front, Evas_Object *back,
1153                           Elm_Fx_Flip_Axis axis, Eina_Bool cw)
1154 {
1155    Elm_Fx_ResizableFlip *resizable_flip;
1156
1157    Elm_Effect *effect;
1158
1159    Evas_Coord front_x, front_y, front_w, front_h;
1160
1161    Evas_Coord back_x, back_y, back_w, back_h;
1162
1163    if (!front || !back)
1164       return NULL;
1165
1166    effect = calloc(1, sizeof(Elm_Effect));
1167    if (!effect)
1168       return NULL;
1169
1170    resizable_flip = calloc(1, sizeof(Elm_Fx_ResizableFlip));
1171
1172    if (!resizable_flip)
1173      {
1174         free(effect);
1175         return NULL;
1176      }
1177
1178    resizable_flip->front = front;
1179    resizable_flip->back = back;
1180    resizable_flip->cw = cw;
1181    resizable_flip->axis = axis;
1182
1183    evas_object_geometry_get(resizable_flip->front, &front_x, &front_y, &front_w,
1184                             &front_h);
1185    evas_object_geometry_get(resizable_flip->back, &back_x, &back_y, &back_w,
1186                             &back_h);
1187
1188    resizable_flip->from_pos.x = front_x;
1189    resizable_flip->from_pos.y = front_y;
1190    resizable_flip->to_pos.x = back_x - front_x;
1191    resizable_flip->to_pos.y = back_y - front_y;
1192
1193    resizable_flip->from_size.x = front_w;
1194    resizable_flip->from_size.y = front_h;
1195    resizable_flip->to_size.x = back_w - front_w;
1196    resizable_flip->to_size.y = back_h - front_h;
1197
1198    effect->begin_op = _elm_fx_resizable_flip_begin;
1199    effect->end_op = _elm_fx_resizable_flip_end;
1200    effect->animation_op = _elm_fx_resizable_flip_op;
1201    effect->user_data = resizable_flip;
1202
1203    return effect;
1204 }
1205
1206 /////////////////////////////////////////////////////////////////////////////////////
1207 //Wipe FX
1208 /////////////////////////////////////////////////////////////////////////////////////
1209 typedef struct _wipe Elm_Fx_Wipe;
1210 static void _elm_fx_wipe_op(void *data, Elm_Animator *animator,
1211                                 double frame);
1212 static void _elm_fx_wipe_begin(void *data, Eina_Bool auto_repeat,
1213                                 unsigned int repeat_cnt);
1214 static void _elm_fx_wipe_end(void *data, Eina_Bool auto_repeat,
1215                                 unsigned int repeat_cnt);
1216 static void _elm_fx_wipe_hide(Evas_Map * map, Elm_Fx_Wipe_Dir dir,
1217                                 float x, float y, float w, float h, float frame);
1218 static void _elm_fx_wipe_show(Evas_Map *map, Elm_Fx_Wipe_Dir dir,
1219                                 float x, float y, float w, float h, float frame);
1220
1221 struct _wipe
1222 {
1223    Evas_Object *obj;
1224    Elm_Fx_Wipe_Type type;
1225    Elm_Fx_Wipe_Dir dir;
1226 };
1227
1228 static void
1229 _elm_fx_wipe_begin(void *data, Eina_Bool auto_repeat, unsigned int repeat_cnt)
1230 {
1231    Elm_Fx_Wipe *wipe = data;
1232
1233    evas_object_show(wipe->obj);
1234    _elm_fx_wipe_op(data, NULL, 0);
1235 }
1236
1237 static void
1238 _elm_fx_wipe_end(void *data, Eina_Bool auto_repeat, unsigned int repeat_cnt)
1239 {
1240    Elm_Fx_Wipe *wipe = data;
1241
1242    evas_object_map_enable_set(wipe->obj, EINA_FALSE);
1243 }
1244
1245 static void
1246 _elm_fx_wipe_hide(Evas_Map * map, Elm_Fx_Wipe_Dir dir, float x, float y,
1247                   float w, float h, float frame)
1248 {
1249    float w2, h2;
1250
1251    switch (dir)
1252      {
1253      case ELM_FX_WIPE_DIR_LEFT:
1254         w2 = w - (w * frame);
1255         h2 = (y + h);
1256         evas_map_point_image_uv_set(map, 0, 0, 0);
1257         evas_map_point_image_uv_set(map, 1, w2, 0);
1258         evas_map_point_image_uv_set(map, 2, w2, h);
1259         evas_map_point_image_uv_set(map, 3, 0, h);
1260         evas_map_point_coord_set(map, 0, x, y, 0);
1261         evas_map_point_coord_set(map, 1, x + w2, y, 0);
1262         evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1263         evas_map_point_coord_set(map, 3, x, h2, 0);
1264         break;
1265      case ELM_FX_WIPE_DIR_RIGHT:
1266         w2 = (w * frame);
1267         h2 = (y + h);
1268         evas_map_point_image_uv_set(map, 0, w2, 0);
1269         evas_map_point_image_uv_set(map, 1, w, 0);
1270         evas_map_point_image_uv_set(map, 2, w, h);
1271         evas_map_point_image_uv_set(map, 3, w2, h);
1272         evas_map_point_coord_set(map, 0, x + w2, y, 0);
1273         evas_map_point_coord_set(map, 1, x + w, y, 0);
1274         evas_map_point_coord_set(map, 2, x + w, h2, 0);
1275         evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1276         break;
1277      case ELM_FX_WIPE_DIR_UP:
1278         w2 = (x + w);
1279         h2 = h - (h * frame);
1280         evas_map_point_image_uv_set(map, 0, 0, 0);
1281         evas_map_point_image_uv_set(map, 1, w, 0);
1282         evas_map_point_image_uv_set(map, 2, w, h2);
1283         evas_map_point_image_uv_set(map, 3, 0, h2);
1284         evas_map_point_coord_set(map, 0, x, y, 0);
1285         evas_map_point_coord_set(map, 1, w2, y, 0);
1286         evas_map_point_coord_set(map, 2, w2, h2, 0);
1287         evas_map_point_coord_set(map, 3, x, h2, 0);
1288         break;
1289      case ELM_FX_WIPE_DIR_DOWN:
1290         w2 = (x + w);
1291         h2 = (h * frame);
1292         evas_map_point_image_uv_set(map, 0, 0, h2);
1293         evas_map_point_image_uv_set(map, 1, w, h2);
1294         evas_map_point_image_uv_set(map, 2, w, h);
1295         evas_map_point_image_uv_set(map, 3, 0, h);
1296         evas_map_point_coord_set(map, 0, x, y + h2, 0);
1297         evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1298         evas_map_point_coord_set(map, 2, w2, y + h, 0);
1299         evas_map_point_coord_set(map, 3, x, y + h, 0);
1300         break;
1301      default:
1302         break;
1303      }
1304
1305    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, 10000);
1306 }
1307
1308 static void
1309 _elm_fx_wipe_show(Evas_Map *map, Elm_Fx_Wipe_Dir dir, float x, float y,
1310                   float w, float h, float frame)
1311 {
1312    float w2, h2;
1313
1314    switch (dir)
1315      {
1316      case ELM_FX_WIPE_DIR_LEFT:
1317         w2 = (w - (w * frame));
1318         h2 = (y + h);
1319         evas_map_point_image_uv_set(map, 0, w2, 0);
1320         evas_map_point_image_uv_set(map, 1, w, 0);
1321         evas_map_point_image_uv_set(map, 2, w, h);
1322         evas_map_point_image_uv_set(map, 3, w2, h);
1323         evas_map_point_coord_set(map, 0, x + w2, y, 0);
1324         evas_map_point_coord_set(map, 1, w, y, 0);
1325         evas_map_point_coord_set(map, 2, w, h2, 0);
1326         evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1327         break;
1328      case ELM_FX_WIPE_DIR_RIGHT:
1329         w2 = (w * frame);
1330         h2 = (y + h);
1331         evas_map_point_image_uv_set(map, 0, 0, 0);
1332         evas_map_point_image_uv_set(map, 1, w2, 0);
1333         evas_map_point_image_uv_set(map, 2, w2, h);
1334         evas_map_point_image_uv_set(map, 3, 0, h);
1335         evas_map_point_coord_set(map, 0, x, y, 0);
1336         evas_map_point_coord_set(map, 1, x + w2, y, 0);
1337         evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1338         evas_map_point_coord_set(map, 3, x, h2, 0);
1339         break;
1340      case ELM_FX_WIPE_DIR_UP:
1341         w2 = (x + w);
1342         h2 = (h - (h * frame));
1343         evas_map_point_image_uv_set(map, 0, 0, h2);
1344         evas_map_point_image_uv_set(map, 1, w, h2);
1345         evas_map_point_image_uv_set(map, 2, w, h);
1346         evas_map_point_image_uv_set(map, 3, 0, h);
1347         evas_map_point_coord_set(map, 0, x, y + h2, 0);
1348         evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1349         evas_map_point_coord_set(map, 2, w2, y + h, 0);
1350         evas_map_point_coord_set(map, 3, x, y + h, 0);
1351         break;
1352      case ELM_FX_WIPE_DIR_DOWN:
1353         w2 = (x + w);
1354         h2 = (h * frame);
1355         evas_map_point_image_uv_set(map, 0, 0, 0);
1356         evas_map_point_image_uv_set(map, 1, w, 0);
1357         evas_map_point_image_uv_set(map, 2, w, h2);
1358         evas_map_point_image_uv_set(map, 3, 0, h2);
1359         evas_map_point_coord_set(map, 0, x, y, 0);
1360         evas_map_point_coord_set(map, 1, w2, y, 0);
1361         evas_map_point_coord_set(map, 2, w2, y + h2, 0);
1362         evas_map_point_coord_set(map, 3, x, y + h2, 0);
1363         break;
1364      default:
1365         break;
1366      }
1367
1368    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, 10000);
1369 }
1370
1371 static void
1372 _elm_fx_wipe_op(void *data, Elm_Animator *animator, double frame)
1373 {
1374    Elm_Fx_Wipe *wipe;
1375
1376    Evas_Map *map;
1377
1378    Evas_Coord _x, _y, _w, _h;
1379
1380    map = evas_map_new(4);
1381    if (!map)
1382       return;
1383
1384    wipe = data;
1385    evas_map_smooth_set(map, EINA_TRUE);
1386    evas_object_geometry_get(wipe->obj, &_x, &_y, &_w, &_h);
1387
1388    if (wipe->type == ELM_FX_WIPE_TYPE_SHOW)
1389       _elm_fx_wipe_show(map, wipe->dir, _x, _y, _w, _h, (float)frame);
1390    else
1391       _elm_fx_wipe_hide(map, wipe->dir, _x, _y, _w, _h, (float)frame);
1392
1393    evas_object_map_enable_set(wipe->obj, EINA_TRUE);
1394    evas_object_map_set(wipe->obj, map);
1395    evas_map_free(map);
1396 }
1397
1398 /**
1399  * Add Wipe effect.
1400  *
1401  * @param obj Evas_Object that effect is applying to
1402  * @param type Wipe type. Hide or show
1403  * @param dir Wipe Direction
1404  * @return Wipe effect
1405  *
1406  * @ingroup Transit
1407  */
1408 EAPI Elm_Effect *
1409 elm_fx_wipe_add(Evas_Object *obj, Elm_Fx_Wipe_Type type, Elm_Fx_Wipe_Dir dir)
1410 {
1411    Elm_Effect *effect;
1412
1413    Elm_Fx_Wipe *wipe;
1414
1415    if (!obj)
1416       return NULL;
1417
1418    effect = calloc(1, sizeof(Elm_Effect));
1419    if (!effect)
1420       return NULL;
1421
1422    wipe = calloc(1, sizeof(Elm_Fx_Wipe));
1423    if (!wipe)
1424      {
1425         free(effect);
1426         return NULL;
1427      }
1428
1429    wipe->obj = obj;
1430    wipe->type = type;
1431    wipe->dir = dir;
1432    effect->begin_op = _elm_fx_wipe_begin;
1433    effect->end_op = _elm_fx_wipe_end;
1434    effect->animation_op = _elm_fx_wipe_op;
1435    effect->user_data = wipe;
1436
1437    return effect;
1438 }
1439
1440 /////////////////////////////////////////////////////////////////////////////////////
1441 //Color FX
1442 /////////////////////////////////////////////////////////////////////////////////////
1443 typedef struct _color Elm_Fx_Color;
1444 static void _elm_fx_color_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt);
1445 static void _elm_fx_color_op(void *data, Elm_Animator *animator, double frame);
1446
1447 struct _color
1448 {
1449    Evas_Object *obj;
1450    struct _unsigned_color
1451    {
1452       unsigned int r, g, b, a;
1453    } from;
1454    struct _signed_color
1455    {
1456       int r, g, b, a;
1457    } to;
1458 };
1459
1460 static void
1461 _elm_fx_color_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1462 {
1463    Elm_Fx_Color *color = data;
1464
1465    evas_object_show(color->obj);
1466 }
1467
1468 static void
1469 _elm_fx_color_op(void *data, Elm_Animator *animator, double frame)
1470 {
1471    Elm_Fx_Color *color;
1472
1473    unsigned int r, g, b, a;
1474
1475    color = data;
1476    r = (color->from.r + (int)((float)color->to.r * frame));
1477    g = (color->from.g + (int)((float)color->to.g * frame));
1478    b = (color->from.b + (int)((float)color->to.b * frame));
1479    a = (color->from.a + (int)((float)color->to.a * frame));
1480
1481    evas_object_color_set(color->obj, r, g, b, a);
1482 }
1483
1484 /**
1485  * Add Color effect.
1486  *
1487  * @param  obj           Evas_Object that effect is applying to
1488  * @param  from_r        RGB R when effect begins
1489  * @param  from_g        RGB G when effect begins
1490  * @param  from_b        RGB B when effect begins
1491  * @param  from_a        RGB A when effect begins
1492  * @param  to_r          RGB R when effect ends
1493  * @param  to_g          RGB G when effect ends
1494  * @param  to_b          RGB B when effect ends
1495  * @param  to_a          RGB A when effect ends
1496  * @return               Color Effect
1497  *
1498  * @ingroup Transit
1499  */
1500 EAPI Elm_Effect *
1501 elm_fx_color_add(Evas_Object *obj, unsigned int from_r, unsigned int from_g,
1502                  unsigned int from_b, unsigned int from_a, unsigned int to_r,
1503                  unsigned int to_g, unsigned int to_b, unsigned int to_a)
1504 {
1505    Elm_Effect *effect;
1506
1507    Elm_Fx_Color *color;
1508
1509    if (!obj)
1510       return NULL;
1511
1512    effect = calloc(1, sizeof(Elm_Effect));
1513    if (!effect)
1514       return NULL;
1515
1516    color = calloc(1, sizeof(Elm_Fx_Color));
1517    if (!color)
1518      {
1519         free(effect);
1520         return NULL;
1521      }
1522
1523    color->obj = obj;
1524    color->from.r = from_r;
1525    color->from.g = from_g;
1526    color->from.b = from_b;
1527    color->from.a = from_a;
1528    color->to.r = to_r - from_r;
1529    color->to.g = to_g - from_g;
1530    color->to.b = to_b - from_b;
1531    color->to.a = to_a - from_a;
1532
1533    effect->begin_op = _elm_fx_color_begin;
1534    effect->animation_op = _elm_fx_color_op;
1535    effect->user_data = color;
1536
1537    return effect;
1538 }
1539
1540 /////////////////////////////////////////////////////////////////////////////////////
1541 //Fade FX
1542 /////////////////////////////////////////////////////////////////////////////////////
1543 typedef struct _fade Elm_Fx_Fade;
1544 static void _elm_fx_fade_begin(void *data, Eina_Bool auto_reverse,
1545                                 unsigned int repeat_cnt);
1546 static void _elm_fx_fade_end(void *data, Eina_Bool auto_reverse,
1547                                 unsigned int repeat_cnt);
1548 static void _elm_fx_fade_op(void *data, Elm_Animator *animator,
1549                                 double frame);
1550
1551 struct _fade
1552 {
1553    Evas_Object *before;
1554    Evas_Object *after;
1555    struct _signed_color before_color, after_color;
1556    int before_alpha;
1557    int after_alpha;
1558    Eina_Bool inversed:1;
1559 };
1560
1561 static void
1562 _elm_fx_fade_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1563 {
1564    Elm_Fx_Fade *fade = data;
1565
1566    fade->inversed = EINA_FALSE;
1567 }
1568
1569 static void
1570 _elm_fx_fade_end(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1571 {
1572    Elm_Fx_Fade *fade = data;
1573
1574    evas_object_color_set(fade->before, fade->before_color.r,
1575                          fade->before_color.g, fade->before_color.b,
1576                          fade->before_color.a);
1577    evas_object_color_set(fade->after, fade->after_color.r, fade->after_color.g,
1578                          fade->after_color.b, fade->after_color.a);
1579 }
1580
1581 static void
1582 _elm_fx_fade_op(void *data, Elm_Animator *animator, double frame)
1583 {
1584    Elm_Fx_Fade *fade;
1585
1586    float _frame;
1587
1588    fade = data;
1589
1590    if (frame < 0.5)
1591      {
1592         if (!fade->inversed)
1593           {
1594              evas_object_hide(fade->after);
1595              evas_object_show(fade->before);
1596              fade->inversed = EINA_TRUE;
1597           }
1598
1599         _frame = (1 - (frame * 2));
1600
1601         evas_object_color_set(fade->before, fade->before_color.r * _frame,
1602                               fade->before_color.g * _frame,
1603                               fade->before_color.b * _frame,
1604                               fade->before_color.a + fade->before_alpha * (1 -
1605                                                                            _frame));
1606      }
1607    else
1608      {
1609         if (fade->inversed)
1610           {
1611              evas_object_hide(fade->before);
1612              evas_object_show(fade->after);
1613              fade->inversed = EINA_FALSE;
1614           }
1615
1616         _frame = ((frame - 0.5) * 2);
1617
1618         evas_object_color_set(fade->after, fade->after_color.r * _frame,
1619                               fade->after_color.g * _frame,
1620                               fade->after_color.b * _frame,
1621                               fade->after_color.a + fade->after_alpha * (1 -
1622                                                                          _frame));
1623      }
1624
1625 }
1626
1627 /**
1628  * Add Fade effect
1629  *
1630  * @param before Evas Object before fade in
1631  * @param after Evas Object after fade out
1632  * @return Fade effect
1633  *
1634  * @ingroup Transit
1635  */
1636 EAPI Elm_Effect *
1637 elm_fx_fade_add(Evas_Object *before, Evas_Object *after)
1638 {
1639    Elm_Effect *effect;
1640
1641    Elm_Fx_Fade *fade;
1642
1643    if ((!before) && (!after))
1644       return NULL;
1645
1646    effect = calloc(1, sizeof(Elm_Effect));
1647    if (!effect)
1648       return NULL;
1649
1650    fade = calloc(1, sizeof(Elm_Fx_Fade));
1651
1652    if (!fade)
1653      {
1654         free(effect);
1655         return NULL;
1656      }
1657
1658    evas_object_color_get(before, &fade->before_color.r, &fade->before_color.g,
1659                          &fade->before_color.b, &fade->before_color.a);
1660    evas_object_color_get(after, &fade->after_color.r, &fade->after_color.g,
1661                          &fade->after_color.b, &fade->after_color.a);
1662
1663    fade->before = before;
1664    fade->after = after;
1665    fade->before_alpha = (255 - fade->before_color.a);
1666    fade->after_alpha = (255 - fade->after_color.a);
1667
1668    effect->begin_op = _elm_fx_fade_begin;
1669    effect->end_op = _elm_fx_fade_end;
1670    effect->animation_op = _elm_fx_fade_op;
1671    effect->user_data = fade;
1672
1673    return effect;
1674 }
1675
1676 /////////////////////////////////////////////////////////////////////////////////////
1677 //Blend FX
1678 /////////////////////////////////////////////////////////////////////////////////////
1679 typedef struct _blend Elm_Fx_Blend;
1680 static void _elm_fx_blend_begin(void *data, Eina_Bool auto_reverse,
1681                                 unsigned int repeat_cnt);
1682 static void _elm_fx_blend_end(void *data, Eina_Bool auto_reverse,
1683                                 unsigned int repeat_cnt);
1684 static void _elm_fx_blend_op(void *data, Elm_Animator *animator,
1685                                 double frame);
1686
1687 struct _blend
1688 {
1689    Evas_Object *before;
1690    Evas_Object *after;
1691    struct _signed_color from, to;
1692 };
1693
1694 static void
1695 _elm_fx_blend_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1696 {
1697    Elm_Fx_Blend *blend = data;
1698
1699    evas_object_show(blend->before);
1700 }
1701
1702 static void
1703 _elm_fx_blend_end(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1704 {
1705    Elm_Fx_Blend *blend = data;
1706
1707    evas_object_color_set(blend->before, blend->from.r, blend->from.g,
1708                          blend->from.b, blend->from.a);
1709    evas_object_color_set(blend->after, blend->to.r, blend->to.g, blend->to.b,
1710                          blend->to.a);
1711    if (!auto_reverse)
1712       evas_object_hide(blend->before);
1713    else
1714       evas_object_hide(blend->after);
1715 }
1716
1717 static void
1718 _elm_fx_blend_op(void *data, Elm_Animator *animator, double frame)
1719 {
1720    Elm_Fx_Blend *blend = data;
1721
1722    evas_object_show(blend->after);
1723    evas_object_color_set(blend->before, (int)(blend->from.r * (1 - frame)),
1724                          (int)(blend->from.g * (1 - frame)),
1725                          (int)(blend->from.b * (1 - frame)),
1726                          (int)(blend->from.a * (1 - frame)));
1727    evas_object_color_set(blend->after, (int)(blend->to.r * frame),
1728                          (int)(blend->to.g * frame), (int)(blend->to.b * frame),
1729                          (int)(blend->to.a * frame));
1730 }
1731
1732 /**
1733  * Add Blend effect
1734  *
1735  * @param before Evas Object before blending
1736  * @param after Evas Object after blending
1737  * @return Blend effect
1738  *
1739  * @ingroup Transit
1740  */
1741 EAPI Elm_Effect *
1742 elm_fx_blend_add(Evas_Object *before, Evas_Object *after)
1743 {
1744    Elm_Effect *effect;
1745
1746    Elm_Fx_Blend *blend;
1747
1748    if ((!before) && (!after))
1749       return NULL;
1750
1751    effect = calloc(1, sizeof(Elm_Effect));
1752    if (!effect)
1753       return NULL;
1754
1755    blend = calloc(1, sizeof(Elm_Fx_Blend));
1756    if (!blend)
1757      {
1758         free(effect);
1759         return NULL;
1760      }
1761
1762    blend->before = before;
1763    blend->after = after;
1764    evas_object_color_get(before, &blend->from.r, &blend->from.g, &blend->from.b,
1765                          &blend->from.a);
1766    evas_object_color_get(after, &blend->to.r, &blend->to.g, &blend->to.b,
1767                          &blend->to.a);
1768
1769    effect->begin_op = _elm_fx_blend_begin;
1770    effect->end_op = _elm_fx_blend_end;
1771    effect->animation_op = _elm_fx_blend_op;
1772    effect->user_data = blend;
1773
1774    return effect;
1775 }
1776
1777 /////////////////////////////////////////////////////////////////////////////////////
1778 //Rotation FX
1779 /////////////////////////////////////////////////////////////////////////////////////
1780 typedef struct _rotation Elm_Fx_Rotation;
1781 static void _elm_fx_rotation_begin(void *data, Eina_Bool auto_reverse,
1782                                 unsigned int repeat_cnt);
1783 static void _elm_fx_rotation_end(void *data, Eina_Bool auto_reverse,
1784                                 unsigned int repeat_cnt);
1785 static void _elm_fx_rotation_op(void *data, Elm_Animator *animator,
1786                                 double frame);
1787
1788 struct _rotation
1789 {
1790    Evas_Object *obj;
1791    Eina_Bool cw;
1792    float from, to;
1793 };
1794
1795 static void
1796 _elm_fx_rotation_begin(void *data, Eina_Bool auto_reverse,
1797                        unsigned int repeat_cnt)
1798 {
1799    Elm_Fx_Rotation *rotation = data;
1800
1801    evas_object_show(rotation->obj);
1802 }
1803
1804 static void
1805 _elm_fx_rotation_end(void *data, Eina_Bool auto_reverse,
1806                      unsigned int repeat_cnt)
1807 {
1808    Elm_Fx_Rotation *rotation = data;
1809
1810    evas_object_map_enable_set(rotation->obj, EINA_FALSE);
1811 }
1812
1813 static void
1814 _elm_fx_rotation_op(void *data, Elm_Animator *animator, double frame)
1815 {
1816    Elm_Fx_Rotation *rotation;
1817
1818    Evas_Map *map;
1819
1820    Evas_Coord x, y, w, h;
1821
1822    float degree;
1823
1824    float half_w, half_h;
1825
1826    map = evas_map_new(4);
1827    if (!map)
1828       return;
1829
1830    rotation = data;
1831
1832    evas_map_smooth_set(map, EINA_TRUE);
1833    evas_map_util_points_populate_from_object_full(map, rotation->obj, 0);
1834    degree = rotation->from + (float)(frame * rotation->to);
1835
1836    if (!rotation->cw)
1837       degree *= -1;
1838
1839    evas_object_geometry_get(rotation->obj, &x, &y, &w, &h);
1840
1841    half_w = (float)w *0.5;
1842
1843    half_h = (float)h *0.5;
1844
1845    evas_map_util_3d_rotate(map, 0, 0, degree, x + half_w, y + half_h, 0);
1846    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
1847    evas_object_map_enable_set(rotation->obj, EINA_TRUE);
1848    evas_object_map_set(rotation->obj, map);
1849    evas_map_free(map);
1850 }
1851
1852 /**
1853  * Add Rotation effect
1854  *
1855  * @param obj Evas_Object that effect is applying to
1856  * @param from degree Degree when effect begins
1857  * @param to_degree Degree when effect is ends
1858  * @param cw Rotation direction. EINA_TRUE is clock wise
1859  * @return Rotation effect
1860  *
1861  * @ingroup Transit
1862  */
1863 EAPI Elm_Effect *
1864 elm_fx_rotation_add(Evas_Object *obj, float from_degree, float to_degree,
1865                     Eina_Bool cw)
1866 {
1867    Elm_Effect *effect;
1868
1869    Elm_Fx_Rotation *rotation;
1870
1871    if (!obj)
1872       return NULL;
1873
1874    effect = calloc(1, sizeof(Elm_Effect));
1875    if (!effect)
1876       return NULL;
1877
1878    rotation = calloc(1, sizeof(Elm_Fx_Rotation));
1879
1880    if (!rotation)
1881      {
1882         free(effect);
1883         return NULL;
1884      }
1885
1886    rotation->obj = obj;
1887    rotation->from = from_degree;
1888    rotation->to = to_degree - from_degree;
1889    rotation->cw = cw;
1890
1891    effect->begin_op = _elm_fx_rotation_begin;
1892    effect->end_op = _elm_fx_rotation_end;
1893    effect->animation_op = _elm_fx_rotation_op;
1894    effect->user_data = rotation;
1895
1896    return effect;
1897 }
1898
1899 /////////////////////////////////////////////////////////////////////////////////////
1900 // ImageAnimation FX
1901 /////////////////////////////////////////////////////////////////////////////////////
1902 typedef struct _image_animation Elm_Fx_Image_Animation;
1903 static void _elm_fx_image_animation_begin(void *data, Eina_Bool auto_reverse,
1904                        unsigned int repeat_cnt);
1905 static void _elm_fx_image_animation_op(void *data, Elm_Animator *animator,
1906                                 double frame);
1907 EAPI Elm_Effect *elm_fx_image_animation_add(Evas_Object *obj, const char **images,
1908                                 unsigned int item_num);
1909
1910 struct _image_animation
1911 {
1912    Evas_Object *obj;
1913    char **images;
1914    int img_cnt;
1915 };
1916
1917
1918 static void
1919 _elm_fx_image_animation_begin(void *data, Eina_Bool auto_reverse,
1920                        unsigned int repeat_cnt)
1921 {
1922    Elm_Fx_Image_Animation *image_animation = data;
1923    evas_object_show(image_animation->obj);
1924 }
1925
1926
1927 static void
1928 _elm_fx_image_animation_op(void *data, Elm_Animator *animator, double frame)
1929 {
1930    Elm_Fx_Image_Animation *image_animation = (Elm_Fx_Image_Animation *) data;
1931    elm_icon_file_set(image_animation->obj,
1932                      image_animation->images[ (int) floor(frame * image_animation->img_cnt) ], NULL);
1933 }
1934
1935 static void
1936 _elm_fx_image_animation_del(void *data)
1937 {
1938         int idx;
1939         Elm_Fx_Image_Animation *image_animation = data;
1940
1941         for(idx = 0; idx < image_animation->img_cnt; ++idx ) {
1942                 eina_stringshare_del(image_animation->images[ idx ]);
1943         }
1944
1945         free(image_animation->images);
1946 }
1947
1948 /**
1949  * Add image_animation effect.
1950  *
1951  * @param obj Icon object
1952  * @param images Array of image file path.
1953  * @param img_cnt Count of image.
1954  * @return ImageAnimation effect.
1955  *
1956  * @ingroup Transit
1957  */
1958 EAPI Elm_Effect *
1959 elm_fx_image_animation_add(Evas_Object *obj, const char **images,
1960                           unsigned int img_cnt)
1961 {
1962    Elm_Effect *effect;
1963    Elm_Fx_Image_Animation *image_animation;
1964    int idx;
1965
1966    if ((!obj) || !images || !(*images))
1967       return NULL;
1968
1969    effect = calloc(1, sizeof(Elm_Effect));
1970    if (!effect)
1971       return NULL;
1972
1973    image_animation = calloc(1, sizeof(Elm_Fx_Image_Animation));
1974
1975    if (!image_animation)
1976      {
1977         free(effect);
1978         return NULL;
1979      }
1980
1981    image_animation->obj = obj;
1982    image_animation->images = calloc( img_cnt, sizeof(char*));
1983    for(idx = 0; idx < img_cnt; ++idx )
1984            image_animation->images[ idx ] = eina_stringshare_add( images[ idx ] );
1985
1986    image_animation->img_cnt = img_cnt;
1987
1988    effect->begin_op = _elm_fx_image_animation_begin;
1989    effect->animation_op = _elm_fx_image_animation_op;
1990    effect->del_op = _elm_fx_image_animation_del;
1991    effect->user_data = image_animation;
1992
1993    return effect;
1994 }