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)
 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         if(flip->back != flip->front) {
 881                 evas_object_hide(flip->back);
 882                 evas_object_show(flip->front);
 883         }
 884      }
 885    else
 886      {
 887         obj = flip->back;
 888         if(flip->back != flip->front) {
 889                 evas_object_hide(flip->front);
 890                 evas_object_show(flip->back);
 891         }
 892      }
 893
 894    evas_map_smooth_set(map, EINA_TRUE);
 895    evas_map_util_points_populate_from_object_full(map, obj, 0);
 896    evas_object_geometry_get(obj, &x, &y, &w, &h);
 897    Evas_Coord half_w = (w / 2);
 898
 899    Evas_Coord half_h = (h / 2);
 900
 901    if (flip->axis == ELM_FX_FLIP_AXIS_Y)
 902      {
 903         if ((degree >= 90) || (degree <= -90))
 904           {
 905              evas_map_point_image_uv_set(map, 0, w, 0);
 906              evas_map_point_image_uv_set(map, 1, 0, 0);
 907              evas_map_point_image_uv_set(map, 2, 0, h);
 908              evas_map_point_image_uv_set(map, 3, w, h);
 909           }
 910         evas_map_util_3d_rotate(map, 0, degree, 0, x + half_w, y + half_h, 0);
 911      }
 912    else
 913      {
 914         if ((degree >= 90) || (degree <= -90))
 915           {
 916              evas_map_point_image_uv_set(map, 0, 0, h);
 917              evas_map_point_image_uv_set(map, 1, w, h);
 918              evas_map_point_image_uv_set(map, 2, w, 0);
 919              evas_map_point_image_uv_set(map, 3, 0, 0);
 920           }
 921         evas_map_util_3d_rotate(map, degree, 0, 0, x + half_w, y + half_h, 0);
 922      }
 923    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
 924    evas_object_map_enable_set(flip->front, EINA_TRUE);
 925    evas_object_map_enable_set(flip->back, EINA_TRUE);
 926    evas_object_map_set(obj, map);
 927    evas_map_free(map);
 928 }
 929
 930 /**
 931  * Add Flip effect.
 932  *
 933  * @param front Front surface object
 934  * @param back Back surface object
 935  * @param axis Flipping Axis(X or Y)
 936  * @param cw Flipping Direction. EINA_TRUE is clock-wise
 937  * @return Flip effect
 938  *
 939  * @ingroup Transit
 940  */
 941 EAPI Elm_Effect *
 942 elm_fx_flip_add(Evas_Object *front, Evas_Object *back, Elm_Fx_Flip_Axis axis,
 943                 Eina_Bool cw)
 944 {
 945    Elm_Effect *effect;
 946
 947    Elm_Fx_Flip *flip;
 948
 949    if ((!front) || (!back))
 950       return NULL;
 951
 952    effect = calloc(1, sizeof(Elm_Effect));
 953    if (!effect)
 954       return NULL;
 955
 956    flip = calloc(1, sizeof(Elm_Fx_Flip));
 957
 958    if (!flip)
 959      {
 960         free(effect);
 961         return NULL;
 962      }
 963
 964    flip->front = front;
 965    flip->back = back;
 966    flip->cw = cw;
 967    flip->axis = axis;
 968    effect->end_op = _elm_fx_flip_end;
 969    effect->animation_op = _elm_fx_flip_op;
 970    effect->user_data = flip;
 971
 972    return effect;
 973 }
 974
 975 /////////////////////////////////////////////////////////////////////////////////////
 976 //ResizableFlip FX
 977 /////////////////////////////////////////////////////////////////////////////////////
 978 typedef struct _resizable_flip Elm_Fx_ResizableFlip;
 979 static void _elm_fx_resizable_flip_begin(void *data, Eina_Bool reverse,
 980                                 unsigned int repeat);
 981 static void _elm_fx_resizable_flip_end(void *data, Eina_Bool auto_reverse,
 982                                 unsigned int repeat_cnt);
 983 static void _elm_fx_resizable_flip_op(void *data, Elm_Animator *animator,
 984                                       double frame);
 985 static void _set_image_uv_by_axis_y(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
 986                                 float degree);
 987 static void _set_image_uv_by_axis_x(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
 988                                 float degree);
 989
 990 struct _resizable_flip
 991 {
 992    Evas_Object *front;
 993    Evas_Object *back;
 994    Elm_Fx_Flip_Axis axis;
 995    struct _vector2d
 996    {
 997       float x, y;
 998    } from_pos, from_size, to_pos, to_size;
 999    Eina_Bool cw:1;
1000 };
1001
1002 static void
1003 _elm_fx_resizable_flip_begin(void *data, Eina_Bool reverse, unsigned int repeat)
1004 {
1005    Elm_Fx_ResizableFlip *resizable_flip = data;
1006
1007    evas_object_show(resizable_flip->front);
1008    _elm_fx_resizable_flip_op(data, NULL, 0);
1009 }
1010
1011 static void
1012 _elm_fx_resizable_flip_end(void *data, Eina_Bool auto_reverse,
1013                            unsigned int repeat_cnt)
1014 {
1015    Elm_Fx_ResizableFlip *resizable_flip = data;
1016
1017    evas_object_map_enable_set(resizable_flip->front, EINA_FALSE);
1018    evas_object_map_enable_set(resizable_flip->back, EINA_FALSE);
1019 }
1020
1021 static void
1022 _set_image_uv_by_axis_y(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
1023                         float degree)
1024 {
1025    if ((degree >= 90) || (degree <= -90))
1026      {
1027         evas_map_point_image_uv_set(map, 0,
1028                                     (flip->from_size.x * 2) + flip->to_size.x,
1029                                     0);
1030         evas_map_point_image_uv_set(map, 1, 0, 0);
1031         evas_map_point_image_uv_set(map, 2, 0,
1032                                     (flip->from_size.y * 2) + flip->to_size.y);
1033         evas_map_point_image_uv_set(map, 3,
1034                                     (flip->from_size.x * 2) + flip->to_size.x,
1035                                     (flip->from_size.y * 2) + flip->to_size.y);
1036      }
1037    else
1038      {
1039         evas_map_point_image_uv_set(map, 0, 0, 0);
1040         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1041         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1042                                     flip->from_size.y);
1043         evas_map_point_image_uv_set(map, 3, 0, flip->to_size.y);
1044      }
1045 }
1046
1047 static void
1048 _set_image_uv_by_axis_x(Evas_Map *map, Elm_Fx_ResizableFlip *flip,
1049                         float degree)
1050 {
1051    if ((degree >= 90) || (degree <= -90))
1052      {
1053         evas_map_point_image_uv_set(map, 0, 0,
1054                                     (flip->from_size.y * 2) + flip->to_size.y);
1055         evas_map_point_image_uv_set(map, 1,
1056                                     (flip->from_size.x * 2) + flip->to_size.x,
1057                                     (flip->from_size.y * 2) + flip->to_size.y);
1058         evas_map_point_image_uv_set(map, 2,
1059                                     (flip->from_size.x * 2) + flip->to_size.x,
1060                                     0);
1061         evas_map_point_image_uv_set(map, 3, 0, 0);
1062      }
1063    else
1064      {
1065         evas_map_point_image_uv_set(map, 0, 0, 0);
1066         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1067         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1068                                     flip->from_size.y);
1069         evas_map_point_image_uv_set(map, 3, 0, flip->to_size.y);
1070      }
1071 }
1072
1073 static void
1074 _elm_fx_resizable_flip_op(void *data, Elm_Animator *animator, double frame)
1075 {
1076    Elm_Fx_ResizableFlip *resizable_flip;
1077
1078    Evas_Map *map;
1079
1080    float degree;
1081
1082    Evas_Object *obj;
1083
1084    float x, y, w, h;
1085
1086    Evas_Coord half_w, half_h;
1087
1088    map = evas_map_new(4);
1089    if (!map)
1090       return;
1091
1092    resizable_flip = data;
1093
1094    if (resizable_flip->cw)
1095       degree = (float)(frame * 180);
1096    else
1097       degree = (float)(frame * -180);
1098
1099    if ((degree < 90) && (degree > -90))
1100      {
1101         obj = resizable_flip->front;
1102         evas_object_hide(resizable_flip->back);
1103         evas_object_show(resizable_flip->front);
1104      }
1105    else
1106      {
1107         obj = resizable_flip->back;
1108         evas_object_hide(resizable_flip->front);
1109         evas_object_show(resizable_flip->back);
1110      }
1111
1112    evas_map_smooth_set(map, EINA_TRUE);
1113
1114    x = resizable_flip->from_pos.x + (resizable_flip->to_pos.x * frame);
1115    y = resizable_flip->from_pos.y + (resizable_flip->to_pos.y * frame);
1116    w = resizable_flip->from_size.x + (resizable_flip->to_size.x * frame);
1117    h = resizable_flip->from_size.y + (resizable_flip->to_size.y * frame);
1118    evas_map_point_coord_set(map, 0, x, y, 0);
1119    evas_map_point_coord_set(map, 1, x + w, y, 0);
1120    evas_map_point_coord_set(map, 2, x + w, y + h, 0);
1121    evas_map_point_coord_set(map, 3, x, y + h, 0);
1122
1123    half_w = (Evas_Coord) (w / 2);
1124    half_h = (Evas_Coord) (h / 2);
1125
1126    if (resizable_flip->axis == ELM_FX_FLIP_AXIS_Y)
1127      {
1128         _set_image_uv_by_axis_y(map, resizable_flip, degree);
1129         evas_map_util_3d_rotate(map, 0, degree, 0, x + half_w, y + half_h, 0);
1130      }
1131    else
1132      {
1133         _set_image_uv_by_axis_x(map, resizable_flip, degree);
1134         evas_map_util_3d_rotate(map, degree, 0, 0, x + half_w, y + half_h, 0);
1135      }
1136
1137    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
1138    evas_object_map_enable_set(resizable_flip->front, EINA_TRUE);
1139    evas_object_map_enable_set(resizable_flip->back, EINA_TRUE);
1140    evas_object_map_set(obj, map);
1141    evas_map_free(map);
1142 }
1143
1144 /**
1145  * Add ResizbleFlip effect. the size of each surface objects are interpolated automatically.
1146  *
1147  * @param front Front surface object
1148  * @param back Back surface object
1149  * @param axis Flipping Axis.(X or Y)
1150  * @param cw Flipping Direction. EINA_TRUE is clock-wise
1151  * @return Flip effect
1152  *
1153  * @ingroup Transit
1154  */
1155 EAPI Elm_Effect *
1156 elm_fx_resizable_flip_add(Evas_Object *front, Evas_Object *back,
1157                           Elm_Fx_Flip_Axis axis, Eina_Bool cw)
1158 {
1159    Elm_Fx_ResizableFlip *resizable_flip;
1160
1161    Elm_Effect *effect;
1162
1163    Evas_Coord front_x, front_y, front_w, front_h;
1164
1165    Evas_Coord back_x, back_y, back_w, back_h;
1166
1167    if (!front || !back)
1168       return NULL;
1169
1170    effect = calloc(1, sizeof(Elm_Effect));
1171    if (!effect)
1172       return NULL;
1173
1174    resizable_flip = calloc(1, sizeof(Elm_Fx_ResizableFlip));
1175
1176    if (!resizable_flip)
1177      {
1178         free(effect);
1179         return NULL;
1180      }
1181
1182    resizable_flip->front = front;
1183    resizable_flip->back = back;
1184    resizable_flip->cw = cw;
1185    resizable_flip->axis = axis;
1186
1187    evas_object_geometry_get(resizable_flip->front, &front_x, &front_y, &front_w,
1188                             &front_h);
1189    evas_object_geometry_get(resizable_flip->back, &back_x, &back_y, &back_w,
1190                             &back_h);
1191
1192    resizable_flip->from_pos.x = front_x;
1193    resizable_flip->from_pos.y = front_y;
1194    resizable_flip->to_pos.x = back_x - front_x;
1195    resizable_flip->to_pos.y = back_y - front_y;
1196
1197    resizable_flip->from_size.x = front_w;
1198    resizable_flip->from_size.y = front_h;
1199    resizable_flip->to_size.x = back_w - front_w;
1200    resizable_flip->to_size.y = back_h - front_h;
1201
1202    effect->begin_op = _elm_fx_resizable_flip_begin;
1203    effect->end_op = _elm_fx_resizable_flip_end;
1204    effect->animation_op = _elm_fx_resizable_flip_op;
1205    effect->user_data = resizable_flip;
1206
1207    return effect;
1208 }
1209
1210 /////////////////////////////////////////////////////////////////////////////////////
1211 //Wipe FX
1212 /////////////////////////////////////////////////////////////////////////////////////
1213 typedef struct _wipe Elm_Fx_Wipe;
1214 static void _elm_fx_wipe_op(void *data, Elm_Animator *animator,
1215                                 double frame);
1216 static void _elm_fx_wipe_begin(void *data, Eina_Bool auto_repeat,
1217                                 unsigned int repeat_cnt);
1218 static void _elm_fx_wipe_end(void *data, Eina_Bool auto_repeat,
1219                                 unsigned int repeat_cnt);
1220 static void _elm_fx_wipe_hide(Evas_Map * map, Elm_Fx_Wipe_Dir dir,
1221                                 float x, float y, float w, float h, float frame);
1222 static void _elm_fx_wipe_show(Evas_Map *map, Elm_Fx_Wipe_Dir dir,
1223                                 float x, float y, float w, float h, float frame);
1224
1225 struct _wipe
1226 {
1227    Evas_Object *obj;
1228    Elm_Fx_Wipe_Type type;
1229    Elm_Fx_Wipe_Dir dir;
1230 };
1231
1232 static void
1233 _elm_fx_wipe_begin(void *data, Eina_Bool auto_repeat, unsigned int repeat_cnt)
1234 {
1235    Elm_Fx_Wipe *wipe = data;
1236
1237    evas_object_show(wipe->obj);
1238    _elm_fx_wipe_op(data, NULL, 0);
1239 }
1240
1241 static void
1242 _elm_fx_wipe_end(void *data, Eina_Bool auto_repeat, unsigned int repeat_cnt)
1243 {
1244    Elm_Fx_Wipe *wipe = data;
1245
1246    evas_object_map_enable_set(wipe->obj, EINA_FALSE);
1247 }
1248
1249 static void
1250 _elm_fx_wipe_hide(Evas_Map * map, Elm_Fx_Wipe_Dir dir, float x, float y,
1251                   float w, float h, float frame)
1252 {
1253    float w2, h2;
1254
1255    switch (dir)
1256      {
1257    case ELM_FX_WIPE_DIR_UP:
1258         w2 = (x + w);
1259         h2 = h - (h * frame);
1260         evas_map_point_image_uv_set(map, 0, 0, 0);
1261         evas_map_point_image_uv_set(map, 1, w, 0);
1262         evas_map_point_image_uv_set(map, 2, w, h2);
1263         evas_map_point_image_uv_set(map, 3, 0, h2);
1264         evas_map_point_coord_set(map, 0, x, y, 0);
1265         evas_map_point_coord_set(map, 1, w2, y, 0);
1266         evas_map_point_coord_set(map, 2, w2, h2, 0);
1267         evas_map_point_coord_set(map, 3, x, h2, 0);
1268         break;
1269      case ELM_FX_WIPE_DIR_LEFT:
1270         w2 = w - (w * frame);
1271         h2 = (y + h);
1272         evas_map_point_image_uv_set(map, 0, 0, 0);
1273         evas_map_point_image_uv_set(map, 1, w2, 0);
1274         evas_map_point_image_uv_set(map, 2, w2, h);
1275         evas_map_point_image_uv_set(map, 3, 0, h);
1276         evas_map_point_coord_set(map, 0, x, y, 0);
1277         evas_map_point_coord_set(map, 1, x + w2, y, 0);
1278         evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1279         evas_map_point_coord_set(map, 3, x, h2, 0);
1280         break;
1281      case ELM_FX_WIPE_DIR_RIGHT:
1282         w2 = (w * frame);
1283         h2 = (y + h);
1284         evas_map_point_image_uv_set(map, 0, w2, 0);
1285         evas_map_point_image_uv_set(map, 1, w, 0);
1286         evas_map_point_image_uv_set(map, 2, w, h);
1287         evas_map_point_image_uv_set(map, 3, w2, h);
1288         evas_map_point_coord_set(map, 0, x + w2, y, 0);
1289         evas_map_point_coord_set(map, 1, x + w, y, 0);
1290         evas_map_point_coord_set(map, 2, x + w, h2, 0);
1291         evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1292         break;
1293      case ELM_FX_WIPE_DIR_DOWN:
1294         w2 = (x + w);
1295         h2 = (h * frame);
1296         evas_map_point_image_uv_set(map, 0, 0, h2);
1297         evas_map_point_image_uv_set(map, 1, w, h2);
1298         evas_map_point_image_uv_set(map, 2, w, h);
1299         evas_map_point_image_uv_set(map, 3, 0, h);
1300         evas_map_point_coord_set(map, 0, x, y + h2, 0);
1301         evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1302         evas_map_point_coord_set(map, 2, w2, y + h, 0);
1303         evas_map_point_coord_set(map, 3, x, y + h, 0);
1304         break;
1305      default:
1306         break;
1307      }
1308
1309    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, 10000);
1310 }
1311
1312 static void
1313 _elm_fx_wipe_show(Evas_Map *map, Elm_Fx_Wipe_Dir dir, float x, float y,
1314                   float w, float h, float frame)
1315 {
1316    float w2, h2;
1317
1318    switch (dir)
1319      {
1320           case ELM_FX_WIPE_DIR_UP:
1321         w2 = (x + w);
1322         h2 = (h - (h * frame));
1323         evas_map_point_image_uv_set(map, 0, 0, h2);
1324         evas_map_point_image_uv_set(map, 1, w, h2);
1325         evas_map_point_image_uv_set(map, 2, w, h);
1326         evas_map_point_image_uv_set(map, 3, 0, h);
1327         evas_map_point_coord_set(map, 0, x, y + h2, 0);
1328         evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1329         evas_map_point_coord_set(map, 2, w2, y + h, 0);
1330         evas_map_point_coord_set(map, 3, x, y + h, 0);
1331         break;
1332      case ELM_FX_WIPE_DIR_LEFT:
1333         w2 = (w - (w * frame));
1334         h2 = (y + h);
1335         evas_map_point_image_uv_set(map, 0, w2, 0);
1336         evas_map_point_image_uv_set(map, 1, w, 0);
1337         evas_map_point_image_uv_set(map, 2, w, h);
1338         evas_map_point_image_uv_set(map, 3, w2, h);
1339         evas_map_point_coord_set(map, 0, x + w2, y, 0);
1340         evas_map_point_coord_set(map, 1, x + w, y, 0);
1341         evas_map_point_coord_set(map, 2, x +w, h2, 0);
1342         evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1343         break;
1344      case ELM_FX_WIPE_DIR_RIGHT:
1345         w2 = (w * frame);
1346         h2 = (y + h);
1347         evas_map_point_image_uv_set(map, 0, 0, 0);
1348         evas_map_point_image_uv_set(map, 1, w2, 0);
1349         evas_map_point_image_uv_set(map, 2, w2, h);
1350         evas_map_point_image_uv_set(map, 3, 0, h);
1351         evas_map_point_coord_set(map, 0, x, y, 0);
1352         evas_map_point_coord_set(map, 1, x + w2, y, 0);
1353         evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1354         evas_map_point_coord_set(map, 3, x, h2, 0);
1355         break;
1356      case ELM_FX_WIPE_DIR_DOWN:
1357         w2 = (x + w);
1358         h2 = (h * frame);
1359         evas_map_point_image_uv_set(map, 0, 0, 0);
1360         evas_map_point_image_uv_set(map, 1, w, 0);
1361         evas_map_point_image_uv_set(map, 2, w, h2);
1362         evas_map_point_image_uv_set(map, 3, 0, h2);
1363         evas_map_point_coord_set(map, 0, x, y, 0);
1364         evas_map_point_coord_set(map, 1, w2, y, 0);
1365         evas_map_point_coord_set(map, 2, w2, y + h2, 0);
1366         evas_map_point_coord_set(map, 3, x, y + h2, 0);
1367         break;
1368      default:
1369         break;
1370      }
1371
1372    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, 10000);
1373 }
1374
1375 static void
1376 _elm_fx_wipe_op(void *data, Elm_Animator *animator, double frame)
1377 {
1378    Elm_Fx_Wipe *wipe;
1379
1380    Evas_Map *map;
1381
1382    Evas_Coord _x, _y, _w, _h;
1383
1384    map = evas_map_new(4);
1385    if (!map)
1386       return;
1387
1388    wipe = data;
1389    evas_map_smooth_set(map, EINA_TRUE);
1390    evas_object_geometry_get(wipe->obj, &_x, &_y, &_w, &_h);
1391
1392    if (wipe->type == ELM_FX_WIPE_TYPE_SHOW)
1393       _elm_fx_wipe_show(map, wipe->dir, _x, _y, _w, _h, (float)frame);
1394    else
1395       _elm_fx_wipe_hide(map, wipe->dir, _x, _y, _w, _h, (float)frame);
1396
1397    evas_object_map_enable_set(wipe->obj, EINA_TRUE);
1398    evas_object_map_set(wipe->obj, map);
1399    evas_map_free(map);
1400 }
1401
1402 /**
1403  * Add Wipe effect.
1404  *
1405  * @param obj Evas_Object that effect is applying to
1406  * @param type Wipe type. Hide or show
1407  * @param dir Wipe Direction
1408  * @return Wipe effect
1409  *
1410  * @ingroup Transit
1411  */
1412 EAPI Elm_Effect *
1413 elm_fx_wipe_add(Evas_Object *obj, Elm_Fx_Wipe_Type type, Elm_Fx_Wipe_Dir dir)
1414 {
1415    Elm_Effect *effect;
1416
1417    Elm_Fx_Wipe *wipe;
1418
1419    if (!obj)
1420       return NULL;
1421
1422    effect = calloc(1, sizeof(Elm_Effect));
1423    if (!effect)
1424       return NULL;
1425
1426    wipe = calloc(1, sizeof(Elm_Fx_Wipe));
1427    if (!wipe)
1428      {
1429         free(effect);
1430         return NULL;
1431      }
1432
1433    wipe->obj = obj;
1434    wipe->type = type;
1435    wipe->dir = dir;
1436    effect->begin_op = _elm_fx_wipe_begin;
1437    effect->end_op = _elm_fx_wipe_end;
1438    effect->animation_op = _elm_fx_wipe_op;
1439    effect->user_data = wipe;
1440
1441    return effect;
1442 }
1443
1444 /////////////////////////////////////////////////////////////////////////////////////
1445 //Color FX
1446 /////////////////////////////////////////////////////////////////////////////////////
1447 typedef struct _color Elm_Fx_Color;
1448 static void _elm_fx_color_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt);
1449 static void _elm_fx_color_op(void *data, Elm_Animator *animator, double frame);
1450
1451 struct _color
1452 {
1453    Evas_Object *obj;
1454    struct _unsigned_color
1455    {
1456       unsigned int r, g, b, a;
1457    } from;
1458    struct _signed_color
1459    {
1460       int r, g, b, a;
1461    } to;
1462 };
1463
1464 static void
1465 _elm_fx_color_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1466 {
1467    Elm_Fx_Color *color = data;
1468
1469    evas_object_show(color->obj);
1470 }
1471
1472 static void
1473 _elm_fx_color_op(void *data, Elm_Animator *animator, double frame)
1474 {
1475    Elm_Fx_Color *color;
1476
1477    unsigned int r, g, b, a;
1478
1479    color = data;
1480    r = (color->from.r + (int)((float)color->to.r * frame));
1481    g = (color->from.g + (int)((float)color->to.g * frame));
1482    b = (color->from.b + (int)((float)color->to.b * frame));
1483    a = (color->from.a + (int)((float)color->to.a * frame));
1484
1485    evas_object_color_set(color->obj, r, g, b, a);
1486 }
1487
1488 /**
1489  * Add Color effect.
1490  *
1491  * @param  obj           Evas_Object that effect is applying to
1492  * @param  from_r        RGB R when effect begins
1493  * @param  from_g        RGB G when effect begins
1494  * @param  from_b        RGB B when effect begins
1495  * @param  from_a        RGB A when effect begins
1496  * @param  to_r          RGB R when effect ends
1497  * @param  to_g          RGB G when effect ends
1498  * @param  to_b          RGB B when effect ends
1499  * @param  to_a          RGB A when effect ends
1500  * @return               Color Effect
1501  *
1502  * @ingroup Transit
1503  */
1504 EAPI Elm_Effect *
1505 elm_fx_color_add(Evas_Object *obj, unsigned int from_r, unsigned int from_g,
1506                  unsigned int from_b, unsigned int from_a, unsigned int to_r,
1507                  unsigned int to_g, unsigned int to_b, unsigned int to_a)
1508 {
1509    Elm_Effect *effect;
1510
1511    Elm_Fx_Color *color;
1512
1513    if (!obj)
1514       return NULL;
1515
1516    effect = calloc(1, sizeof(Elm_Effect));
1517    if (!effect)
1518       return NULL;
1519
1520    color = calloc(1, sizeof(Elm_Fx_Color));
1521    if (!color)
1522      {
1523         free(effect);
1524         return NULL;
1525      }
1526
1527    color->obj = obj;
1528    color->from.r = from_r;
1529    color->from.g = from_g;
1530    color->from.b = from_b;
1531    color->from.a = from_a;
1532    color->to.r = to_r - from_r;
1533    color->to.g = to_g - from_g;
1534    color->to.b = to_b - from_b;
1535    color->to.a = to_a - from_a;
1536
1537    effect->begin_op = _elm_fx_color_begin;
1538    effect->animation_op = _elm_fx_color_op;
1539    effect->user_data = color;
1540
1541    return effect;
1542 }
1543
1544 /////////////////////////////////////////////////////////////////////////////////////
1545 //Fade FX
1546 /////////////////////////////////////////////////////////////////////////////////////
1547 typedef struct _fade Elm_Fx_Fade;
1548 static void _elm_fx_fade_begin(void *data, Eina_Bool auto_reverse,
1549                                 unsigned int repeat_cnt);
1550 static void _elm_fx_fade_end(void *data, Eina_Bool auto_reverse,
1551                                 unsigned int repeat_cnt);
1552 static void _elm_fx_fade_op(void *data, Elm_Animator *animator,
1553                                 double frame);
1554
1555 struct _fade
1556 {
1557    Evas_Object *before;
1558    Evas_Object *after;
1559    struct _signed_color before_color, after_color;
1560    int before_alpha;
1561    int after_alpha;
1562    Eina_Bool inversed:1;
1563 };
1564
1565 static void
1566 _elm_fx_fade_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1567 {
1568    Elm_Fx_Fade *fade = data;
1569
1570    fade->inversed = EINA_FALSE;
1571 }
1572
1573 static void
1574 _elm_fx_fade_end(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1575 {
1576    Elm_Fx_Fade *fade = data;
1577
1578    evas_object_color_set(fade->before, fade->before_color.r,
1579                          fade->before_color.g, fade->before_color.b,
1580                          fade->before_color.a);
1581    evas_object_color_set(fade->after, fade->after_color.r, fade->after_color.g,
1582                          fade->after_color.b, fade->after_color.a);
1583 }
1584
1585 static void
1586 _elm_fx_fade_op(void *data, Elm_Animator *animator, double frame)
1587 {
1588    Elm_Fx_Fade *fade;
1589
1590    float _frame;
1591
1592    fade = data;
1593
1594    if (frame < 0.5)
1595      {
1596         if (!fade->inversed)
1597           {
1598              evas_object_hide(fade->after);
1599              evas_object_show(fade->before);
1600              fade->inversed = EINA_TRUE;
1601           }
1602
1603         _frame = (1 - (frame * 2));
1604
1605         evas_object_color_set(fade->before, fade->before_color.r * _frame,
1606                               fade->before_color.g * _frame,
1607                               fade->before_color.b * _frame,
1608                               fade->before_color.a + fade->before_alpha * (1 -
1609                                                                            _frame));
1610      }
1611    else
1612      {
1613         if (fade->inversed)
1614           {
1615              evas_object_hide(fade->before);
1616              evas_object_show(fade->after);
1617              fade->inversed = EINA_FALSE;
1618           }
1619
1620         _frame = ((frame - 0.5) * 2);
1621
1622         evas_object_color_set(fade->after, fade->after_color.r * _frame,
1623                               fade->after_color.g * _frame,
1624                               fade->after_color.b * _frame,
1625                               fade->after_color.a + fade->after_alpha * (1 -
1626                                                                          _frame));
1627      }
1628
1629 }
1630
1631 /**
1632  * Add Fade effect
1633  *
1634  * @param before Evas Object before fade in
1635  * @param after Evas Object after fade out
1636  * @return Fade effect
1637  *
1638  * @ingroup Transit
1639  */
1640 EAPI Elm_Effect *
1641 elm_fx_fade_add(Evas_Object *before, Evas_Object *after)
1642 {
1643    Elm_Effect *effect;
1644
1645    Elm_Fx_Fade *fade;
1646
1647    if ((!before) && (!after))
1648       return NULL;
1649
1650    effect = calloc(1, sizeof(Elm_Effect));
1651    if (!effect)
1652       return NULL;
1653
1654    fade = calloc(1, sizeof(Elm_Fx_Fade));
1655
1656    if (!fade)
1657      {
1658         free(effect);
1659         return NULL;
1660      }
1661
1662    evas_object_color_get(before, &fade->before_color.r, &fade->before_color.g,
1663                          &fade->before_color.b, &fade->before_color.a);
1664    evas_object_color_get(after, &fade->after_color.r, &fade->after_color.g,
1665                          &fade->after_color.b, &fade->after_color.a);
1666
1667    fade->before = before;
1668    fade->after = after;
1669    fade->before_alpha = (255 - fade->before_color.a);
1670    fade->after_alpha = (255 - fade->after_color.a);
1671
1672    effect->begin_op = _elm_fx_fade_begin;
1673    effect->end_op = _elm_fx_fade_end;
1674    effect->animation_op = _elm_fx_fade_op;
1675    effect->user_data = fade;
1676
1677    return effect;
1678 }
1679
1680 /////////////////////////////////////////////////////////////////////////////////////
1681 //Blend FX
1682 /////////////////////////////////////////////////////////////////////////////////////
1683 typedef struct _blend Elm_Fx_Blend;
1684 static void _elm_fx_blend_begin(void *data, Eina_Bool auto_reverse,
1685                                 unsigned int repeat_cnt);
1686 static void _elm_fx_blend_end(void *data, Eina_Bool auto_reverse,
1687                                 unsigned int repeat_cnt);
1688 static void _elm_fx_blend_op(void *data, Elm_Animator *animator,
1689                                 double frame);
1690
1691 struct _blend
1692 {
1693    Evas_Object *before;
1694    Evas_Object *after;
1695    struct _signed_color from, to;
1696 };
1697
1698 static void
1699 _elm_fx_blend_begin(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1700 {
1701    Elm_Fx_Blend *blend = data;
1702
1703    evas_object_show(blend->before);
1704 }
1705
1706 static void
1707 _elm_fx_blend_end(void *data, Eina_Bool auto_reverse, unsigned int repeat_cnt)
1708 {
1709    Elm_Fx_Blend *blend = data;
1710
1711    evas_object_color_set(blend->before, blend->from.r, blend->from.g,
1712                          blend->from.b, blend->from.a);
1713    evas_object_color_set(blend->after, blend->to.r, blend->to.g, blend->to.b,
1714                          blend->to.a);
1715    if (!auto_reverse)
1716       evas_object_hide(blend->before);
1717    else
1718       evas_object_hide(blend->after);
1719 }
1720
1721 static void
1722 _elm_fx_blend_op(void *data, Elm_Animator *animator, double frame)
1723 {
1724    Elm_Fx_Blend *blend = data;
1725
1726    evas_object_show(blend->after);
1727    evas_object_color_set(blend->before, (int)(blend->from.r * (1 - frame)),
1728                          (int)(blend->from.g * (1 - frame)),
1729                          (int)(blend->from.b * (1 - frame)),
1730                          (int)(blend->from.a * (1 - frame)));
1731    evas_object_color_set(blend->after, (int)(blend->to.r * frame),
1732                          (int)(blend->to.g * frame), (int)(blend->to.b * frame),
1733                          (int)(blend->to.a * frame));
1734 }
1735
1736 /**
1737  * Add Blend effect
1738  *
1739  * @param before Evas Object before blending
1740  * @param after Evas Object after blending
1741  * @return Blend effect
1742  *
1743  * @ingroup Transit
1744  */
1745 EAPI Elm_Effect *
1746 elm_fx_blend_add(Evas_Object *before, Evas_Object *after)
1747 {
1748    Elm_Effect *effect;
1749
1750    Elm_Fx_Blend *blend;
1751
1752    if ((!before) && (!after))
1753       return NULL;
1754
1755    effect = calloc(1, sizeof(Elm_Effect));
1756    if (!effect)
1757       return NULL;
1758
1759    blend = calloc(1, sizeof(Elm_Fx_Blend));
1760    if (!blend)
1761      {
1762         free(effect);
1763         return NULL;
1764      }
1765
1766    blend->before = before;
1767    blend->after = after;
1768    evas_object_color_get(before, &blend->from.r, &blend->from.g, &blend->from.b,
1769                          &blend->from.a);
1770    evas_object_color_get(after, &blend->to.r, &blend->to.g, &blend->to.b,
1771                          &blend->to.a);
1772
1773    effect->begin_op = _elm_fx_blend_begin;
1774    effect->end_op = _elm_fx_blend_end;
1775    effect->animation_op = _elm_fx_blend_op;
1776    effect->user_data = blend;
1777
1778    return effect;
1779 }
1780
1781 /////////////////////////////////////////////////////////////////////////////////////
1782 //Rotation FX
1783 /////////////////////////////////////////////////////////////////////////////////////
1784 typedef struct _rotation Elm_Fx_Rotation;
1785 static void _elm_fx_rotation_begin(void *data, Eina_Bool auto_reverse,
1786                                 unsigned int repeat_cnt);
1787 static void _elm_fx_rotation_end(void *data, Eina_Bool auto_reverse,
1788                                 unsigned int repeat_cnt);
1789 static void _elm_fx_rotation_op(void *data, Elm_Animator *animator,
1790                                 double frame);
1791
1792 struct _rotation
1793 {
1794    Evas_Object *obj;
1795    Eina_Bool cw;
1796    float from, to;
1797 };
1798
1799 static void
1800 _elm_fx_rotation_begin(void *data, Eina_Bool auto_reverse,
1801                        unsigned int repeat_cnt)
1802 {
1803    Elm_Fx_Rotation *rotation = data;
1804
1805    evas_object_show(rotation->obj);
1806 }
1807
1808 static void
1809 _elm_fx_rotation_end(void *data, Eina_Bool auto_reverse,
1810                      unsigned int repeat_cnt)
1811 {
1812    Elm_Fx_Rotation *rotation = data;
1813
1814    evas_object_map_enable_set(rotation->obj, EINA_FALSE);
1815 }
1816
1817 static void
1818 _elm_fx_rotation_op(void *data, Elm_Animator *animator, double frame)
1819 {
1820    Elm_Fx_Rotation *rotation;
1821
1822    Evas_Map *map;
1823
1824    Evas_Coord x, y, w, h;
1825
1826    float degree;
1827
1828    float half_w, half_h;
1829
1830    map = evas_map_new(4);
1831    if (!map)
1832       return;
1833
1834    rotation = data;
1835
1836    evas_map_smooth_set(map, EINA_TRUE);
1837    evas_map_util_points_populate_from_object_full(map, rotation->obj, 0);
1838    degree = rotation->from + (float)(frame * rotation->to);
1839
1840    if (!rotation->cw)
1841       degree *= -1;
1842
1843    evas_object_geometry_get(rotation->obj, &x, &y, &w, &h);
1844
1845    half_w = (float)w *0.5;
1846
1847    half_h = (float)h *0.5;
1848
1849    evas_map_util_3d_rotate(map, 0, 0, degree, x + half_w, y + half_h, 0);
1850    evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, 10000);
1851    evas_object_map_enable_set(rotation->obj, EINA_TRUE);
1852    evas_object_map_set(rotation->obj, map);
1853    evas_map_free(map);
1854 }
1855
1856 /**
1857  * Add Rotation effect
1858  *
1859  * @param obj Evas_Object that effect is applying to
1860  * @param from degree Degree when effect begins
1861  * @param to_degree Degree when effect is ends
1862  * @param cw Rotation direction. EINA_TRUE is clock wise
1863  * @return Rotation effect
1864  *
1865  * @ingroup Transit
1866  */
1867 EAPI Elm_Effect *
1868 elm_fx_rotation_add(Evas_Object *obj, float from_degree, float to_degree,
1869                     Eina_Bool cw)
1870 {
1871    Elm_Effect *effect;
1872
1873    Elm_Fx_Rotation *rotation;
1874
1875    if (!obj)
1876       return NULL;
1877
1878    effect = calloc(1, sizeof(Elm_Effect));
1879    if (!effect)
1880       return NULL;
1881
1882    rotation = calloc(1, sizeof(Elm_Fx_Rotation));
1883
1884    if (!rotation)
1885      {
1886         free(effect);
1887         return NULL;
1888      }
1889
1890    rotation->obj = obj;
1891    rotation->from = from_degree;
1892    rotation->to = to_degree - from_degree;
1893    rotation->cw = cw;
1894
1895    effect->begin_op = _elm_fx_rotation_begin;
1896    effect->end_op = _elm_fx_rotation_end;
1897    effect->animation_op = _elm_fx_rotation_op;
1898    effect->user_data = rotation;
1899
1900    return effect;
1901 }
1902
1903 /////////////////////////////////////////////////////////////////////////////////////
1904 // ImageAnimation FX
1905 /////////////////////////////////////////////////////////////////////////////////////
1906 typedef struct _image_animation Elm_Fx_Image_Animation;
1907 static void _elm_fx_image_animation_begin(void *data, Eina_Bool auto_reverse,
1908                        unsigned int repeat_cnt);
1909 static void _elm_fx_image_animation_op(void *data, Elm_Animator *animator,
1910                                 double frame);
1911 EAPI Elm_Effect *elm_fx_image_animation_add(Evas_Object *obj, const char **images,
1912                                 unsigned int item_num);
1913
1914 struct _image_animation
1915 {
1916    Evas_Object *obj;
1917    char **images;
1918    int img_cnt;
1919 };
1920
1921
1922 static void
1923 _elm_fx_image_animation_begin(void *data, Eina_Bool auto_reverse,
1924                        unsigned int repeat_cnt)
1925 {
1926    Elm_Fx_Image_Animation *image_animation = data;
1927    evas_object_show(image_animation->obj);
1928 }
1929
1930
1931 static void
1932 _elm_fx_image_animation_op(void *data, Elm_Animator *animator, double frame)
1933 {
1934    Elm_Fx_Image_Animation *image_animation = (Elm_Fx_Image_Animation *) data;
1935
1936    elm_icon_file_set(image_animation->obj,
1937                      image_animation->images[ (int) floor(frame * (image_animation->img_cnt-1)) ], NULL);
1938 }
1939
1940 static void
1941 _elm_fx_image_animation_del(void *data)
1942 {
1943         int idx;
1944         Elm_Fx_Image_Animation *image_animation = data;
1945
1946         for(idx = 0; idx < image_animation->img_cnt; ++idx ) {
1947                 eina_stringshare_del(image_animation->images[ idx ]);
1948         }
1949
1950         free(image_animation->images);
1951 }
1952
1953 /**
1954  * Add image_animation effect.
1955  *
1956  * @param obj Icon object
1957  * @param images Array of image file path.
1958  * @param img_cnt Count of image.
1959  * @return ImageAnimation effect.
1960  *
1961  * @ingroup Transit
1962  */
1963 EAPI Elm_Effect *
1964 elm_fx_image_animation_add(Evas_Object *obj, const char **images,
1965                           unsigned int img_cnt)
1966 {
1967    Elm_Effect *effect;
1968    Elm_Fx_Image_Animation *image_animation;
1969    int idx;
1970
1971    if ((!obj) || !images || !(*images))
1972       return NULL;
1973
1974    effect = calloc(1, sizeof(Elm_Effect));
1975    if (!effect)
1976       return NULL;
1977
1978    image_animation = calloc(1, sizeof(Elm_Fx_Image_Animation));
1979
1980    if (!image_animation)
1981      {
1982         free(effect);
1983         return NULL;
1984      }
1985
1986    image_animation->obj = obj;
1987    image_animation->images = calloc( img_cnt, sizeof(char*));
1988    for(idx = 0; idx < img_cnt; ++idx )
1989            image_animation->images[ idx ] = eina_stringshare_add( images[ idx ] );
1990
1991    image_animation->img_cnt = img_cnt;
1992
1993    effect->begin_op = _elm_fx_image_animation_begin;
1994    effect->animation_op = _elm_fx_image_animation_op;
1995    effect->del_op = _elm_fx_image_animation_del;
1996    effect->user_data = image_animation;
1997
1998    return effect;
1999 }