src/lib/elm_transit.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 #define ELM_TRANSIT_CHECK_OR_RETURN(transit, ...) \
   5    do { \
   6       if (!transit) { \
   7          CRITICAL("Elm_Transit " # transit " is NULL!"); \
   8          return __VA_ARGS__; \
   9       } \
  10       if (!EINA_MAGIC_CHECK(transit, ELM_TRANSIT_MAGIC)) { \
  11          EINA_MAGIC_FAIL(transit, ELM_TRANSIT_MAGIC); \
  12          return __VA_ARGS__; \
  13       } \
  14       if (transit->deleted){ \
  15          ERR("Elm_Transit " # transit " has already been deleted!"); \
  16          return __VA_ARGS__; \
  17       } \
  18    } while (0)
  19
  20 /**
  21  *
  22  * @defgroup Transit Transit
  23  * @ingroup Elementary
  24  *
  25  * Transit (see Warning below) is designed to set the various effects for the
  26  * Evas_Object such like translation, rotation, etc. For using Effects, Create
  27  * transit and insert effects which are interesting.
  28  * Once effects are inserted into transit, transit will manage those effects.
  29  * (ex deleting).
  30  *
  31  * Example:
  32  * @code
  33  * Elm_Transit *trans = elm_transit_add();
  34  * elm_transit_object_add(trans, obj);
  35  * void *effect_context = elm_transit_effect_translation_context_new(0.0, 0.0,
  36  *                                                               280.0, 280.0);
  37  * elm_transit_effect_add(transit,
  38  *                        elm_transit_effect_translation_op, effect_context,
  39  *                        elm_transit_effect_translation_context_free);
  40  * elm_transit_duration_set(transit, 5);
  41  * elm_transit_auto_reverse_set(transit, EINA_TRUE);
  42  * elm_transit_tween_mode_set(transit, ELM_TRANSIT_TWEEN_MODE_DECELERATE);
  43  * elm_transit_repeat_times_set(transit, -1);
  44  * @endcode
  45  *
  46  * @warning We strongly recomend to use elm_transit just when edje can not do
  47  * the trick. Edje has more advantage than Elm_Transit, it has more flexibility and
  48  * animations can be manipulated inside the theme.
  49  */
  50
  51 static const char _transit_key[] = "_elm_transit";
  52
  53 #define FOCAL 2000
  54
  55 struct _Elm_Transit
  56 {
  57 #define ELM_TRANSIT_MAGIC 0xd27f190a
  58    EINA_MAGIC;
  59
  60    Ecore_Animator *animator;
  61    Eina_List *effect_list;
  62    Eina_List *objs;
  63    Elm_Transit_Tween_Mode tween_mode;
  64    struct {
  65       void (*func) (void *data, Elm_Transit *transit);
  66       void *arg;
  67    } del_data;
  68    struct {
  69       double delayed;
  70       double paused;
  71       double duration;
  72       double begin;
  73       double current;
  74    } time;
  75    struct {
  76       int count;
  77       int current;
  78       Eina_Bool reverse;
  79    } repeat;
  80    double progress;
  81    unsigned int effects_pending_del;
  82    int walking;
  83    Eina_Bool auto_reverse : 1;
  84    Eina_Bool event_enabled : 1;
  85    Eina_Bool deleted : 1;
  86 };
  87
  88 struct _Elm_Transit_Effect
  89 {
  90    void (*animation_op) (void *data, Elm_Transit *transit, double progress);
  91    void (*user_data_free) (void *data, Elm_Transit *transit);
  92    void *user_data;
  93    Eina_Bool deleted : 1;
  94 };
  95
  96 struct _Elm_Obj_Data
  97 {
  98    Eina_Bool state;
  99    Elm_Transit *transit;
 100 };
 101
 102 typedef struct _Elm_Transit_Effect Elm_Transit_Effect;
 103 typedef struct _Elm_Obj_Data Elm_Obj_Data;
 104
 105 static void
 106 _elm_transit_object_remove_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
 107 {
 108    Elm_Transit *transit = data;
 109
 110    Elm_Obj_Data *obj_data = evas_object_data_del(obj, _transit_key);
 111    evas_object_pass_events_set(obj, obj_data->state);
 112    free(obj_data);
 113    transit->objs = eina_list_remove(transit->objs, obj);
 114    if (!transit->objs) elm_transit_del(transit);
 115 }
 116
 117 static void
 118 _elm_transit_object_remove(Elm_Transit *transit, Evas_Object *obj)
 119 {
 120    Elm_Obj_Data *obj_data = evas_object_data_del(obj, _transit_key);
 121
 122    evas_object_pass_events_set(obj, obj_data->state);
 123    free(obj_data);
 124    transit->objs = eina_list_remove(transit->objs, obj);
 125    evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL,
 126                                   _elm_transit_object_remove_cb);
 127 }
 128
 129 static void
 130 _elm_transit_effect_del(Elm_Transit *transit, Elm_Transit_Effect *effect, Eina_List *elist)
 131 {
 132    if (effect->user_data_free)
 133       effect->user_data_free(effect->user_data, transit);
 134
 135    transit->effect_list = eina_list_remove_list(transit->effect_list, elist);
 136    free(effect);
 137 }
 138
 139 static void
 140 _remove_dead_effects(Elm_Transit *transit)
 141 {
 142    Eina_List *elist, *elist_next;
 143    Elm_Transit_Effect *effect;
 144
 145    EINA_LIST_FOREACH_SAFE(transit->effect_list, elist, elist_next, effect)
 146      {
 147         if (effect->deleted)
 148           {
 149              _elm_transit_effect_del(transit, effect, elist);
 150              transit->effects_pending_del--;
 151              if (!transit->effects_pending_del) return;
 152           }
 153      }
 154 }
 155
 156 static void
 157 _elm_transit_del(Elm_Transit *transit)
 158 {
 159    Eina_List *elist, *elist_next;
 160    Elm_Transit_Effect *effect;
 161
 162    if (transit->animator)
 163       ecore_animator_del(transit->animator);
 164
 165    EINA_LIST_FOREACH_SAFE(transit->effect_list, elist, elist_next, effect)
 166       _elm_transit_effect_del(transit, effect, elist);
 167
 168    while (transit->objs)
 169       _elm_transit_object_remove(transit, eina_list_data_get(transit->objs));
 170
 171    if (transit->del_data.func)
 172       transit->del_data.func(transit->del_data.arg, transit);
 173
 174    EINA_MAGIC_SET(transit, EINA_MAGIC_NONE);
 175    free(transit);
 176 }
 177
 178 static void
 179 _transit_animate_op(Elm_Transit *transit, double progress)
 180 {
 181    Eina_List *elist;
 182    Elm_Transit_Effect *effect;
 183
 184    transit->walking++;
 185    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
 186      {
 187         if (transit->deleted) break;
 188         if (!effect->deleted)
 189            effect->animation_op(effect->user_data, transit, progress);
 190      }
 191    transit->walking--;
 192
 193    if (transit->walking) return;
 194
 195    if (transit->deleted) _elm_transit_del(transit);
 196    else if (transit->effects_pending_del) _remove_dead_effects(transit);
 197 }
 198
 199 static Eina_Bool
 200 _animator_animate_cb(void *data)
 201 {
 202    Elm_Transit *transit = data;
 203    double elapsed_time, duration;
 204
 205    transit->time.current = ecore_loop_time_get();
 206    elapsed_time = transit->time.current - transit->time.begin;
 207    duration = transit->time.duration + transit->time.delayed;
 208
 209    if (elapsed_time > duration)
 210       elapsed_time = duration;
 211
 212    transit->progress = elapsed_time / duration;
 213    switch (transit->tween_mode)
 214      {
 215       case ELM_TRANSIT_TWEEN_MODE_ACCELERATE:
 216         transit->progress = 1.0 - sin((ELM_PI / 2.0) + (transit->progress * ELM_PI / 2.0));
 217         break;
 218       case ELM_TRANSIT_TWEEN_MODE_DECELERATE:
 219         transit->progress = sin(transit->progress * ELM_PI / 2.0);
 220         break;
 221       case ELM_TRANSIT_TWEEN_MODE_SINUSOIDAL:
 222         transit->progress = (1.0 - cos(transit->progress * ELM_PI)) / 2.0;
 223         break;
 224       default:
 225         break;
 226      }
 227
 228    /* Reverse? */
 229    if (transit->repeat.reverse) transit->progress = 1 - transit->progress;
 230
 231    if (transit->time.duration > 0) _transit_animate_op(transit, transit->progress);
 232
 233    /* Not end. Keep going. */
 234    if (elapsed_time < duration) return ECORE_CALLBACK_RENEW;
 235
 236    /* Repeat and reverse and time done! */
 237    if ((transit->repeat.current == transit->repeat.count)
 238        && (!transit->auto_reverse || transit->repeat.reverse))
 239      {
 240         elm_transit_del(transit);
 241         return ECORE_CALLBACK_CANCEL;
 242      }
 243
 244    /* Repeat Case */
 245    if (!transit->auto_reverse || transit->repeat.reverse)
 246      {
 247         transit->repeat.current++;
 248         transit->repeat.reverse = EINA_FALSE;
 249      }
 250    else transit->repeat.reverse = EINA_TRUE;
 251
 252    transit->time.begin = ecore_loop_time_get();
 253
 254    return ECORE_CALLBACK_RENEW;
 255 }
 256
 257 /**
 258  * Add new transit.
 259  *
 260  * @note Is not necessary to delete the transit object, it will be deleted at
 261  * the end of its operation.
 262  * @note The transit will start playing when the program enter in the main loop, is not
 263  * necessary to give a start to the transit.
 264  *
 265  * @param duration The duration of the transit in seconds. When transit starts
 266  * to run, it will last a @p duration time.
 267  * @return The transit object.
 268  *
 269  * @ingroup Transit
 270  */
 271 EAPI Elm_Transit *
 272 elm_transit_add(void)
 273 {
 274    Elm_Transit *transit = ELM_NEW(Elm_Transit);
 275    if (!transit) return NULL;
 276
 277    EINA_MAGIC_SET(transit, ELM_TRANSIT_MAGIC);
 278
 279    elm_transit_tween_mode_set(transit, ELM_TRANSIT_TWEEN_MODE_LINEAR);
 280
 281    return transit;
 282 }
 283 /**
 284  * Stops the animation and delete the @p transit object.
 285  *
 286  * Call this function if you wants to stop the animation before the duration
 287  * time. Make sure the @p transit object is still alive with
 288  * elm_transit_del_cb_set() function.
 289  * All added effects will be deleted, calling its repective data_free_cb
 290  * functions. The function setted by elm_tansit_del_cb_set() will be called.
 291  *
 292  * @see elm_transit_del_cb_set()
 293  *
 294  * @param transit The transit object to be deleted.
 295  *
 296  * @ingroup Transit
 297  * @warning Just call this function if you are sure the transit is alive.
 298  */
 299 EAPI void
 300 elm_transit_del(Elm_Transit *transit)
 301 {
 302    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 303
 304    if (transit->walking) transit->deleted = EINA_TRUE;
 305    else _elm_transit_del(transit);
 306 }
 307
 308 /**
 309  * Add a new effect to the transit.
 310  *
 311  * @note The cb function and the data are the key to the effect. If you try to
 312  * add an already added effect, nothing is done.
 313  * @note After the first addition of an effect in @p transit, if its
 314  * effect list become empty again, the @p transit will be killed by
 315  * elm_transit_del(transit) function.
 316  *
 317  * Exemple:
 318  * @code
 319  * Elm_Transit *transit = elm_transit_add();
 320  * elm_transit_effect_add(transit,
 321  *                        elm_transit_effect_blend_op,
 322  *                        elm_transit_effect_blend_context_new(),
 323  *                        elm_transit_effect_blend_context_free);
 324  * @endcode
 325  *
 326  * @param transit The transit object.
 327  * @param cb The operation function. It is called when the animation begins,
 328  * it is the function that actually performs the animation. It is called with
 329  * the @p data, @p transit and the time progression of the animation (a double
 330  * value between 0.0 and 1.0).
 331  * @param data The context data of the effect.
 332  * @param data_free_cb The function to free the context data, it will be called
 333  * at the end of the effect, it must finalize the animation and free the
 334  * @p data.
 335  *
 336  * @ingroup Transit
 337  * @warning The transit free the context data at the and of the transition with
 338  * the data_free_cb function, do not use the context data in another transit.
 339  */
 340 EAPI void
 341 elm_transit_effect_add(Elm_Transit *transit, void (*cb)(void *data, Elm_Transit *transit, double progress), void *data, void (*data_free_cb)(void *data, Elm_Transit *transit))
 342 {
 343    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 344    EINA_SAFETY_ON_NULL_RETURN(cb);
 345    Elm_Transit_Effect *effect;
 346    Eina_List *elist;
 347
 348    EINA_LIST_FOREACH(transit->effect_list, elist, effect)
 349      {
 350         if ((effect->animation_op == cb) && (effect->user_data == data)) return;
 351      }
 352
 353    effect = ELM_NEW(Elm_Transit_Effect);
 354    if (!effect) return;
 355
 356    effect->user_data_free = data_free_cb;
 357    effect->animation_op = cb;
 358    effect->user_data = data;
 359
 360    transit->effect_list = eina_list_append(transit->effect_list, effect);
 361 }
 362
 363 /**
 364  * Delete an added effect.
 365  *
 366  * This function will remove the effect from the @p transit, calling the
 367  * data_free_cb to free the @p data.
 368  *
 369  * @see elm_transit_effect_add()
 370  *
 371  * @note If the effect is not found, nothing is done.
 372  * @note If the effect list become empty, this function will call
 373  * elm_transit_del(transit), that is, it will kill the @p transit.
 374  *
 375  * @param transit The transit object.
 376  * @param cb The operation function.
 377  * @param data The context data of the effect.
 378  *
 379  * @ingroup Transit
 380  */
 381 EAPI void
 382 elm_transit_effect_del(Elm_Transit *transit, void (*cb)(void *data, Elm_Transit *transit, double progress), void *data)
 383 {
 384    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 385    EINA_SAFETY_ON_NULL_RETURN(cb);
 386    Eina_List *elist, *elist_next;
 387    Elm_Transit_Effect *effect;
 388
 389    EINA_LIST_FOREACH_SAFE(transit->effect_list, elist, elist_next, effect)
 390      {
 391         if ((effect->animation_op == cb) && (effect->user_data == data))
 392           {
 393              if (transit->walking)
 394                {
 395                   effect->deleted = EINA_TRUE;
 396                   transit->effects_pending_del++;
 397                }
 398              else
 399                {
 400                   _elm_transit_effect_del(transit, effect, elist);
 401                   if (!transit->effect_list) elm_transit_del(transit);
 402                }
 403              return;
 404           }
 405      }
 406 }
 407
 408 /**
 409  * Add new object to apply the effects.
 410  *
 411  * @note After the first addition of an object in @p transit, if its
 412  * object list become empty again, the @p transit will be killed by
 413  * elm_transit_del(transit) function.
 414  * @note If the @p obj belongs to another transit, the @p obj will be
 415  * removed from it and it will only belong to the @p transit. If the old
 416  * transit stays without objects, it will die.
 417  * @note When you add an object into the @p transit, its state from
 418  * evas_object_pass_events_get(obj) is saved, and it is applied when the
 419  * transit ends, if you change this state whith evas_object_pass_events_set()
 420  * after add the object, this state will change again when @p transit stops to
 421  * run.
 422  *
 423  * @param transit The transit object.
 424  * @param obj Object to be animated.
 425  *
 426  * @ingroup Transit
 427  * @warning See the documentation of the effect if is safe add or remove
 428  * an object after @p transit begins to run.
 429  */
 430 EAPI void
 431 elm_transit_object_add(Elm_Transit *transit, Evas_Object *obj)
 432 {
 433    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 434    EINA_SAFETY_ON_NULL_RETURN(obj);
 435    Elm_Obj_Data *obj_data = evas_object_data_get(obj, _transit_key);
 436
 437    if (obj_data)
 438      {
 439         if (obj_data->transit == transit) return;
 440         elm_transit_object_remove(obj_data->transit, obj);
 441      }
 442
 443    obj_data = ELM_NEW(Elm_Obj_Data);
 444    obj_data->state = evas_object_pass_events_get(obj);
 445    obj_data->transit = transit;
 446    evas_object_data_set(obj, _transit_key, obj_data);
 447
 448    transit->objs = eina_list_append(transit->objs, obj);
 449
 450    if (!transit->event_enabled)
 451       evas_object_pass_events_set(obj, EINA_TRUE);
 452
 453    evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
 454                                   _elm_transit_object_remove_cb, transit);
 455 }
 456
 457 /**
 458  * Removes an added object from the transit.
 459  *
 460  * @note If the @p obj is not in the @p transit, nothing is done.
 461  * @note If the list become empty, this function will call
 462  * elm_transit_del(transit), that is, it will kill the @p transit.
 463  *
 464  * @param transit The transit object.
 465  * @param obj Object to be removed from @p transit.
 466  *
 467  * @ingroup Transit
 468  * @warning See the documentation of the effect if is safe add or remove
 469  * an object after @p transit begins to run.
 470  */
 471 EAPI void
 472 elm_transit_object_remove(Elm_Transit *transit, Evas_Object *obj)
 473 {
 474    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 475    EINA_SAFETY_ON_NULL_RETURN(obj);
 476    Elm_Obj_Data *obj_data = evas_object_data_get(obj, _transit_key);
 477    if ((!obj_data) || (obj_data->transit != transit)) return;
 478
 479    _elm_transit_object_remove(transit, obj);
 480    if (!transit->objs) elm_transit_del(transit);
 481 }
 482
 483 /**
 484  * Get the objects of the transit.
 485  *
 486  * @param transit The transit object.
 487  * @return a Eina_List with the objects from the transit.
 488  *
 489  * @ingroup Transit
 490  */
 491 EAPI const Eina_List *
 492 elm_transit_objects_get(const Elm_Transit *transit)
 493 {
 494    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
 495    return transit->objs;
 496 }
 497
 498 /**
 499  * Set the event enabled when transit is operating.
 500  *
 501  * If @p enabled is EINA_TRUE, the objects of the transit will receives
 502  * events from mouse and keyboard during the animation.
 503  * @note When you add an object with elm_transit_object_add(), its state from
 504  * evas_object_pass_events_get(obj) is saved, and it is applied when the
 505  * transit ends, if you change this state with evas_object_pass_events_set()
 506  * after add the object, this state will change again when @p transit stops to
 507  * run.
 508  *
 509  * @param transit The transit object.
 510  * @param enabled Disable or enable.
 511  *
 512  * @ingroup Transit
 513  */
 514 EAPI void
 515 elm_transit_event_enabled_set(Elm_Transit *transit, Eina_Bool enabled)
 516 {
 517    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 518    Evas_Object *obj;
 519    Eina_List *elist;
 520    Elm_Obj_Data *obj_data;
 521
 522    if (transit->event_enabled == enabled) return;
 523
 524    transit->event_enabled = enabled;
 525
 526    if (enabled)
 527      {
 528         EINA_LIST_FOREACH(transit->objs, elist, obj)
 529           {
 530              obj_data = evas_object_data_get(obj, _transit_key);
 531              evas_object_pass_events_set(obj, obj_data->state);
 532           }
 533      }
 534    else
 535      {
 536         EINA_LIST_FOREACH(transit->objs, elist, obj)
 537            evas_object_pass_events_set(obj, EINA_TRUE);
 538      }
 539 }
 540
 541 /**
 542  * Get the value of event enabled status.
 543  *
 544  * @see elm_transit_event_enabled_set()
 545  *
 546  * @param transit The Transit object
 547  * @return EINA_TRUE, when event is enabled. If @p transit is NULL
 548  * EINA_FALSE is returned
 549  *
 550  * @ingroup Transit
 551  */
 552 EAPI Eina_Bool
 553 elm_transit_event_enabled_get(const Elm_Transit *transit)
 554 {
 555    ELM_TRANSIT_CHECK_OR_RETURN(transit, EINA_FALSE);
 556
 557    return transit->event_enabled;
 558 }
 559
 560
 561 /**
 562  * Set the event enabled when transit is operating.
 563  *
 564  * If @p disabled is EINA_TRUE, the objects of the transit will receives
 565  * events from mouse and keyboard during the animation.
 566  * @note When you add an object with elm_transit_object_add(), its state from
 567  * evas_object_pass_events_get(obj) is saved, and it is applied when the
 568  * transit ends, if you change this state with evas_object_pass_events_set()
 569  * after add the object, this state will change again when @p transit stops to
 570  * run.
 571  *
 572  * @see elm_transit_event_enabled_set()
 573  *
 574  * @param transit The transit object.
 575  * @param disabled Disable or enable.
 576  *
 577  * @ingroup Transit
 578  */
 579 EINA_DEPRECATED EAPI void
 580 elm_transit_event_block_set(Elm_Transit *transit, Eina_Bool disabled)
 581 {
 582    elm_transit_event_enabled_set(transit, disabled);
 583 }
 584
 585
 586 /**
 587  * Get the value of event block enabled  status.
 588  *
 589  * @see elm_transit_event_enabled_set(), elm_transit_event_enabled_get()
 590  *
 591  * @param transit The Transit object
 592  * @return EINA_TRUE, when event is enabled. If @p transit is NULL
 593  * EINA_FALSE is returned
 594  *
 595  * @ingroup Transit
 596  */
 597 EINA_DEPRECATED EAPI Eina_Bool
 598 elm_transit_event_block_get(const Elm_Transit *transit)
 599 {
 600    return !elm_transit_event_enabled_get(transit);
 601 }
 602
 603 /**
 604  * Set the user-callback function when the transit is deleted.
 605  *
 606  * @note Using this function twice will overwrite the first function setted.
 607  * @note the @p transit object will be deleted after call @p cb function.
 608  *
 609  * @param transit The transit object.
 610  * @param cb Callback function pointer. This function will be called before
 611  * the deletion of the transit.
 612  * @param data Callback funtion user data. It is the @p op parameter.
 613  *
 614  * @ingroup Transit
 615  */
 616 EAPI void
 617 elm_transit_del_cb_set(Elm_Transit *transit, void (*cb) (void *data, Elm_Transit *transit), void *data)
 618 {
 619    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 620    transit->del_data.func = cb;
 621    transit->del_data.arg = data;
 622 }
 623
 624 /**
 625  * Set reverse effect automatically.
 626  *
 627  * If auto reverse is setted, after running the effects with the progress
 628  * parameter from 0 to 1, it will call the effecs again with the progress
 629  * from 1 to 0. The transit will last for a time iqual to (2 * duration * repeat),
 630  * where the duration was setted with the function elm_transit_add and
 631  * the repeat with the function elm_transit_repeat_times_set().
 632  *
 633  * @param transit The transit object.
 634  * @param reverse EINA_TRUE means the auto_reverse is on.
 635  *
 636  * @ingroup Transit
 637  */
 638 EAPI void
 639 elm_transit_auto_reverse_set(Elm_Transit *transit, Eina_Bool reverse)
 640 {
 641    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 642    transit->auto_reverse = reverse;
 643 }
 644
 645 /**
 646  * Get if the auto reverse is on.
 647  *
 648  * @see elm_transit_auto_reverse_set()
 649  *
 650  * @param transit The transit object.
 651  * @return EINA_TRUE means auto reverse is on. If @p transit is NULL
 652  * EINA_FALSE is returned
 653  *
 654  * @ingroup Transit
 655  */
 656 EAPI Eina_Bool
 657 elm_transit_auto_reverse_get(Elm_Transit *transit)
 658 {
 659    ELM_TRANSIT_CHECK_OR_RETURN(transit, EINA_FALSE);
 660    return transit->auto_reverse;
 661 }
 662
 663 /**
 664  * Set the transit repeat count. Effect will be repeated by repeat count.
 665  *
 666  * This function sets the number of repetition the transit will run after
 667  * the first one, that is, if @p repeat is 1, the transit will run 2 times.
 668  * If the @p repeat is a negative number, it will repeat infinite times.
 669  *
 670  * @note If this function is called during the transit execution, the transit
 671  * will run @p repeat times, ignoring the times it already performed.
 672  *
 673  * @param transit The transit object
 674  * @param repeat Repeat count
 675  *
 676  * @ingroup Transit
 677  */
 678 EAPI void
 679 elm_transit_repeat_times_set(Elm_Transit *transit, int repeat)
 680 {
 681    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 682    transit->repeat.count = repeat;
 683    transit->repeat.current = 0;
 684 }
 685
 686 /**
 687  * Get the transit repeat count.
 688  *
 689  * @see elm_transit_repeat_times_set()
 690  *
 691  * @param transit The Transit object.
 692  * @return The repeat count. If @p transit is NULL
 693  * 0 is returned
 694  *
 695  * @ingroup Transit
 696  */
 697 EAPI int
 698 elm_transit_repeat_times_get(Elm_Transit *transit)
 699 {
 700    ELM_TRANSIT_CHECK_OR_RETURN(transit, 0);
 701    return transit->repeat.count;
 702 }
 703
 704 /**
 705  * Set the transit animation acceleration type.
 706  *
 707  * This function sets the tween mode of the transit that can be:
 708  * ELM_TRANSIT_TWEEN_MODE_LINEAR - The default mode.
 709  * ELM_TRANSIT_TWEEN_MODE_SINUSOIDAL - Starts in accelerate mode and ends decelerating.
 710  * ELM_TRANSIT_TWEEN_MODE_DECELERATE - The animation will be slowed over time.
 711  * ELM_TRANSIT_TWEEN_MODE_ACCELERATE - The animation will accelerate over time.
 712  *
 713  * @param transit The transit object.
 714  * @param tween_mode The tween type.
 715  *
 716  * @ingroup Transit
 717  */
 718 EAPI void
 719 elm_transit_tween_mode_set(Elm_Transit *transit, Elm_Transit_Tween_Mode tween_mode)
 720 {
 721    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 722
 723    transit->tween_mode = tween_mode;
 724 }
 725
 726 /**
 727  * Get the transit animation acceleration type.
 728  *
 729  * @note @p transit can not be NULL
 730  *
 731  * @param transit The transit object.
 732  * @return The tween type. If @p transit is NULL
 733  * ELM_TRANSIT_TWEEN_MODE_LINEAR is returned.
 734  *
 735  * @ingroup Transit
 736  */
 737 EAPI Elm_Transit_Tween_Mode
 738 elm_transit_tween_mode_get(const Elm_Transit *transit)
 739 {
 740    ELM_TRANSIT_CHECK_OR_RETURN(transit, ELM_TRANSIT_TWEEN_MODE_LINEAR);
 741    return transit->tween_mode;
 742 }
 743
 744 /**
 745  * Set the transit animation time
 746  *
 747  * @note @p transit can not be NULL
 748  *
 749  * @param transit The transit object.
 750  * @param duration The animation time.
 751  *
 752  * @ingroup Transit
 753  */
 754 EAPI void
 755 elm_transit_duration_set(Elm_Transit *transit, double duration)
 756 {
 757    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 758    if (transit->animator) return;
 759    transit->time.duration = duration;
 760 }
 761
 762 /**
 763  * Get the transit animation time
 764  *
 765  * @note @p transit can not be NULL
 766  *
 767  * @param transit The transit object.
 768  *
 769  * @return The transit animation time.
 770  *
 771  * @ingroup Transit
 772  */
 773 EAPI double
 774 elm_transit_duration_get(const Elm_Transit *transit)
 775 {
 776    ELM_TRANSIT_CHECK_OR_RETURN(transit, 0.0);
 777    return transit->time.duration;
 778 }
 779
 780 /**
 781  * Starts the transition.
 782  * Once this API is called, the transit begins to measure the time.
 783  *
 784  * @note @p transit can not be NULL
 785  *
 786  * @param transit The transit object.
 787  *
 788  * @ingroup Transit
 789  */
 790 EAPI void
 791 elm_transit_go(Elm_Transit *transit)
 792 {
 793    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 794
 795    if (transit->animator)
 796       ecore_animator_del(transit->animator);
 797
 798    transit->time.paused = 0;
 799    transit->time.delayed = 0;
 800    transit->time.begin = ecore_loop_time_get();
 801    transit->animator = ecore_animator_add(_animator_animate_cb, transit);
 802 }
 803
 804 /**
 805  * Pause/Resume the transition.
 806  * If you call elm_transit_go again, paused states will affect no anymore.
 807  *
 808  * @note @p transit can not be NULL
 809  *
 810  * @param transit The transit object.
 811  *
 812  * @ingroup Transit
 813  */
 814 EAPI void
 815 elm_transit_paused_set(Elm_Transit *transit, Eina_Bool paused)
 816 {
 817    ELM_TRANSIT_CHECK_OR_RETURN(transit);
 818
 819    if (!transit->animator) return;
 820
 821    if (paused)
 822      {
 823         if (transit->time.paused > 0)
 824            return;
 825         ecore_animator_freeze(transit->animator);
 826         transit->time.paused = ecore_loop_time_get();
 827      }
 828    else
 829      {
 830         if (transit->time.paused == 0)
 831            return;
 832         ecore_animator_thaw(transit->animator);
 833         transit->time.delayed += (ecore_loop_time_get() - transit->time.paused);
 834         transit->time.paused = 0;
 835      }
 836 }
 837
 838 /**
 839  * Get the value of paused status.
 840  *
 841  * @see elm_transit_paused_set()
 842  *
 843  * @note @p transit can not be NULL
 844  *
 845  * @param transit The transit object.
 846  * @return EINA_TRUE means transition is paused. If @p transit is NULL
 847  * EINA_FALSE is returned
 848  *
 849  * @ingroup Transit
 850  */
 851 EAPI Eina_Bool
 852 elm_transit_paused_get(const Elm_Transit *transit)
 853 {
 854    ELM_TRANSIT_CHECK_OR_RETURN(transit, EINA_FALSE);
 855
 856    if (transit->time.paused == 0)
 857       return EINA_FALSE;
 858
 859    return EINA_TRUE;
 860 }
 861
 862 /**
 863  * Get the time progression of the animation (a double value between 0.0 and 1.0).
 864  *
 865  * @note @p transit can not be NULL
 866  *
 867  * @param transit The transit object.
 868  *
 869  * @return The time progression value. If @p transit is NULL
 870  * 0 is returned
 871  *
 872  * @ingroup Transit
 873  */
 874 EAPI double
 875 elm_transit_progress_value_get(const Elm_Transit *transit)
 876 {
 877    ELM_TRANSIT_CHECK_OR_RETURN(transit, 0);
 878
 879    return transit->progress;
 880 }
 881
 882 ///////////////////////////////////////////////////////////////////////////////
 883 //Resizing FX
 884 ///////////////////////////////////////////////////////////////////////////////
 885 typedef struct _Elm_Transit_Effect_Resizing Elm_Transit_Effect_Resizing;
 886
 887 struct _Elm_Transit_Effect_Resizing
 888 {
 889    struct _size {
 890       Evas_Coord w, h;
 891    } from, to;
 892 };
 893
 894 static void
 895 _transit_effect_resizing_context_free(void *data, Elm_Transit *transit __UNUSED__)
 896 {
 897    free(data);
 898 }
 899
 900 static void
 901 _transit_effect_resizing_op(void *data, Elm_Transit *transit, double progress)
 902 {
 903    EINA_SAFETY_ON_NULL_RETURN(data);
 904    EINA_SAFETY_ON_NULL_RETURN(transit);
 905    Evas_Coord w, h;
 906    Evas_Object *obj;
 907    Eina_List *elist;
 908    Elm_Transit_Effect_Resizing *resizing = data;
 909
 910    w = resizing->from.w + (resizing->to.w * progress);
 911    h = resizing->from.h + (resizing->to.h * progress);
 912
 913    EINA_LIST_FOREACH(transit->objs, elist, obj)
 914       evas_object_resize(obj, w, h);
 915 }
 916
 917 static void *
 918 _transit_effect_resizing_context_new(Evas_Coord from_w, Evas_Coord from_h, Evas_Coord to_w, Evas_Coord to_h)
 919 {
 920    Elm_Transit_Effect_Resizing *resizing;
 921
 922    resizing = ELM_NEW(Elm_Transit_Effect_Resizing);
 923    if (!resizing) return NULL;
 924
 925    resizing->from.w = from_w;
 926    resizing->from.h = from_h;
 927    resizing->to.w = to_w - from_w;
 928    resizing->to.h = to_h - from_h;
 929
 930    return resizing;
 931 }
 932
 933 /**
 934  * Add the Resizing Effect to Elm_Transit.
 935  *
 936  * @note This API is one of the facades. It creates resizing effect context
 937  * and add it's required APIs to elm_transit_effect_add.
 938  * @note This effect will be applied to the objects that are in the transit,
 939  * @note If you change the set of objects in the transit with  elm_transit_object_add()
 940  * or elm_transit_object_remove(), the set of objects affected by this effect
 941  * will be changed too.
 942  *
 943  * @see elm_transit_effect_add()
 944  *
 945  * @param transit Transit object.
 946  * @param from_w Object width size when effect begins.
 947  * @param from_h Object height size when effect begins.
 948  * @param to_w Object width size when effect ends.
 949  * @param to_h Object height size when effect ends.
 950  * @return Resizing effect context data.
 951  *
 952  * @ingroup Transit
 953  */
 954 EAPI void *
 955 elm_transit_effect_resizing_add(Elm_Transit *transit, Evas_Coord from_w, Evas_Coord from_h, Evas_Coord to_w, Evas_Coord to_h)
 956 {
 957    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
 958    void *effect_context = _transit_effect_resizing_context_new(from_w, from_h, to_w, to_h);
 959
 960    if (!effect_context) return NULL;
 961    elm_transit_effect_add(transit,
 962                           _transit_effect_resizing_op, effect_context,
 963                           _transit_effect_resizing_context_free);
 964    return effect_context;
 965 }
 966
 967 ///////////////////////////////////////////////////////////////////////////////
 968 //Translation FX
 969 ///////////////////////////////////////////////////////////////////////////////
 970 typedef struct _Elm_Transit_Effect_Translation Elm_Transit_Effect_Translation;
 971 typedef struct _Elm_Transit_Effect_Translation_Node Elm_Transit_Effect_Translation_Node;
 972
 973 struct _Elm_Transit_Effect_Translation_Node
 974 {
 975    Evas_Object *obj;
 976    Evas_Coord x, y;
 977 };
 978
 979 struct _Elm_Transit_Effect_Translation
 980 {
 981    struct _position_variation {
 982       Evas_Coord dx, dy;
 983    } from, to;
 984    Eina_List *nodes;
 985 };
 986
 987 static void
 988 _translation_object_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
 989 {
 990    Elm_Transit_Effect_Translation *translation = data;
 991    Eina_List *elist;
 992    Elm_Transit_Effect_Translation_Node *translation_node;
 993
 994    EINA_LIST_FOREACH(translation->nodes, elist, translation_node)
 995      {
 996         if (translation_node->obj != obj) continue;
 997         translation->nodes = eina_list_remove_list(translation->nodes, elist);
 998         free(translation_node);
 999         break;
1000      }
1001 }
1002
1003 static Eina_List *
1004 _translation_nodes_build(Elm_Transit *transit, Elm_Transit_Effect_Translation *translation)
1005 {
1006    Elm_Transit_Effect_Translation_Node *translation_node;
1007    const Eina_List *elist;
1008    Evas_Object *obj;
1009    Eina_List *data_list = NULL;
1010    const Eina_List *objs = elm_transit_objects_get(transit);
1011
1012    EINA_LIST_FOREACH(objs, elist, obj)
1013      {
1014         translation_node = ELM_NEW(Elm_Transit_Effect_Translation_Node);
1015         if (!translation_node)
1016           {
1017              eina_list_free(data_list);
1018              return NULL;
1019           }
1020         translation_node->obj = obj;
1021         evas_object_geometry_get(obj, &(translation_node->x),
1022                                  &(translation_node->y), NULL, NULL);
1023         data_list = eina_list_append(data_list, translation_node);
1024         evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
1025                                        _translation_object_del_cb, translation);
1026      }
1027    return data_list;
1028 }
1029
1030 void
1031 _transit_effect_translation_context_free(void *data, Elm_Transit *transit __UNUSED__)
1032 {
1033    EINA_SAFETY_ON_NULL_RETURN(data);
1034    Elm_Transit_Effect_Translation *translation = data;
1035    Eina_List *elist, *elist_next;
1036    Elm_Transit_Effect_Translation_Node *translation_node;
1037
1038    EINA_LIST_FOREACH_SAFE(translation->nodes,
1039                           elist, elist_next, translation_node)
1040      {
1041         evas_object_event_callback_del(translation_node->obj,
1042                                        EVAS_CALLBACK_DEL, _translation_object_del_cb);
1043         translation->nodes = eina_list_remove_list(translation->nodes, elist);
1044         free(translation_node);
1045      }
1046    free(translation);
1047 }
1048
1049 void
1050 _transit_effect_translation_op(void *data, Elm_Transit *transit, double progress __UNUSED__)
1051 {
1052    EINA_SAFETY_ON_NULL_RETURN(data);
1053    EINA_SAFETY_ON_NULL_RETURN(transit);
1054    Evas_Coord x, y;
1055    Elm_Transit_Effect_Translation *translation = data;
1056    Elm_Transit_Effect_Translation_Node *translation_node;
1057    Eina_List *elist;
1058
1059    if (!translation->nodes)
1060       translation->nodes = _translation_nodes_build(transit, translation);
1061
1062    EINA_LIST_FOREACH(translation->nodes, elist, translation_node)
1063      {
1064         x = translation_node->x + translation->from.dx
1065            + (translation->to.dx * progress);
1066         y = translation_node->y + translation->from.dy
1067            + (translation->to.dy * progress);
1068         evas_object_move(translation_node->obj, x, y);
1069      }
1070 }
1071
1072 static void *
1073 _transit_effect_translation_context_new(Evas_Coord from_dx, Evas_Coord from_dy, Evas_Coord to_dx, Evas_Coord to_dy)
1074 {
1075    Elm_Transit_Effect_Translation *translation;
1076
1077    translation = ELM_NEW(Elm_Transit_Effect_Translation);
1078    if (!translation) return NULL;
1079
1080    translation->from.dx = from_dx;
1081    translation->from.dy = from_dy;
1082    translation->to.dx = to_dx - from_dx;
1083    translation->to.dy = to_dy - from_dy;
1084
1085    return translation;
1086 }
1087
1088 /**
1089  * Add the Translation Effect to Elm_Transit.
1090  *
1091  * @note This API is one of the facades. It creates translation effect context
1092  * and add it's required APIs to elm_transit_effect_add.
1093  * @note When this function is called, it gets the current objects in
1094  * the transit, that is, elm_transit_object_remove() and elm_transit_object_add()
1095  * will not cause any changes in the set of objects that this effect is being
1096  * applied.
1097  *
1098  * @see elm_transit_effect_add()
1099  *
1100  * @param transit Transit object.
1101  * @param from_dx X Position variation when effect begins.
1102  * @param from_dy Y Position variation when effect begins.
1103  * @param to_dx X Position variation when effect ends.
1104  * @param to_dy Y Position variation when effect ends.
1105  * @return Translation effect context data.
1106  *
1107  * @ingroup Transit
1108  * @warning Is higher recommended just create a transit with this effect when
1109  * the window that the objects of the transit belongs has already been created.
1110  * This is because this effect needs the geometry information about the objects,
1111  * and if the window was not created yet, it can get a wrong information.
1112  * @warning Is not recommended remove or add an object after the transit begins
1113  * to run, because the order of the objects will be affected.
1114  */
1115 EAPI void *
1116 elm_transit_effect_translation_add(Elm_Transit *transit, Evas_Coord from_dx, Evas_Coord from_dy, Evas_Coord to_dx, Evas_Coord to_dy)
1117 {
1118    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
1119    void *effect_context = _transit_effect_translation_context_new(from_dx, from_dy, to_dx, to_dy);
1120
1121    if (!effect_context) return NULL;
1122    elm_transit_effect_add(transit,
1123                           _transit_effect_translation_op, effect_context,
1124                           _transit_effect_translation_context_free);
1125    return effect_context;
1126 }
1127
1128
1129 ///////////////////////////////////////////////////////////////////////////////
1130 //Zoom FX
1131 ///////////////////////////////////////////////////////////////////////////////
1132 typedef struct _Elm_Transit_Effect_Zoom Elm_Transit_Effect_Zoom;
1133
1134 struct _Elm_Transit_Effect_Zoom
1135 {
1136    float from, to;
1137 };
1138
1139 void
1140 _transit_effect_zoom_context_free(void *data, Elm_Transit *transit __UNUSED__)
1141 {
1142    free(data);
1143 }
1144
1145 static void
1146 _transit_effect_zoom_op(void *data, Elm_Transit *transit , double progress)
1147 {
1148    EINA_SAFETY_ON_NULL_RETURN(data);
1149    EINA_SAFETY_ON_NULL_RETURN(transit);
1150    Evas_Object *obj;
1151    Eina_List *elist;
1152    Elm_Transit_Effect_Zoom *zoom = data;
1153    Evas_Map *map;
1154    Evas_Coord x, y, w, h;
1155
1156    map = evas_map_new(4);
1157    if (!map) return;
1158
1159    EINA_LIST_FOREACH(transit->objs, elist, obj)
1160      {
1161         evas_object_geometry_get(obj, &x, &y, &w, &h);
1162         evas_map_util_points_populate_from_object_full(map, obj, zoom->from +
1163                                                        (progress * zoom->to));
1164         evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, FOCAL);
1165         evas_object_map_set(obj, map);
1166         evas_object_map_enable_set(obj, EINA_TRUE);
1167      }
1168    evas_map_free(map);
1169 }
1170
1171 static void *
1172 _transit_effect_zoom_context_new(float from_rate, float to_rate)
1173 {
1174    Elm_Transit_Effect_Zoom *zoom;
1175
1176    zoom = ELM_NEW(Elm_Transit_Effect_Zoom);
1177    if (!zoom) return NULL;
1178
1179    zoom->from = (FOCAL - (from_rate * FOCAL)) * (1 / from_rate);
1180    zoom->to = ((FOCAL - (to_rate * FOCAL)) * (1 / to_rate)) - zoom->from;
1181
1182    return zoom;
1183 }
1184
1185 /**
1186  * Add the Zoom Effect to Elm_Transit.
1187  *
1188  * @note This API is one of the facades. It creates zoom effect context
1189  * and add it's required APIs to elm_transit_effect_add.
1190  * @note If you change the set of objects in the transit with  elm_transit_object_add()
1191  * or elm_transit_object_remove(), the set of objects affected by this effect
1192  * will be changed too.
1193  *
1194  * @see elm_transit_effect_add()
1195  *
1196  * @param transit Transit object.
1197  * @param from_rate Scale rate when effect begins (1 is current rate).
1198  * @param to_rate Scale rate when effect ends.
1199  * @return Zoom effect context data.
1200  *
1201  * @ingroup Transit
1202  * @warning Is higher recommended just create a transit with this effect when
1203  * the window that the objects of the transit belongs has already been created.
1204  * This is because this effect needs the geometry information about the objects,
1205  * and if the window was not created yet, it can get a wrong information.
1206  * @warning Is not recommended remove or add an object after the transit begins
1207  * to run, because the order of the objects will be affected.
1208  */
1209 EAPI void *
1210 elm_transit_effect_zoom_add(Elm_Transit *transit, float from_rate, float to_rate)
1211 {
1212    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
1213    void *effect_context = _transit_effect_zoom_context_new(from_rate, to_rate);
1214
1215    if (!effect_context) return NULL;
1216    elm_transit_effect_add(transit,
1217                           _transit_effect_zoom_op, effect_context,
1218                           _transit_effect_zoom_context_free);
1219    return effect_context;
1220 }
1221
1222
1223 ///////////////////////////////////////////////////////////////////////////////
1224 //Flip FX
1225 ///////////////////////////////////////////////////////////////////////////////
1226 typedef struct _Elm_Transit_Effect_Flip Elm_Transit_Effect_Flip;
1227
1228 struct _Elm_Transit_Effect_Flip
1229 {
1230    Elm_Transit_Effect_Flip_Axis axis;
1231    Eina_Bool cw : 1;
1232 };
1233
1234 static void
1235 _transit_effect_flip_context_free(void *data, Elm_Transit *transit)
1236 {
1237    EINA_SAFETY_ON_NULL_RETURN(data);
1238    EINA_SAFETY_ON_NULL_RETURN(transit);
1239    Evas_Object *front, *back;
1240    int i;
1241    int count = eina_list_count(transit->objs);
1242
1243    for (i = 0; i < (count - 1); i += 2)
1244      {
1245         front = eina_list_nth(transit->objs, i);
1246         back = eina_list_nth(transit->objs, i+1);
1247         evas_object_map_enable_set(front, EINA_FALSE);
1248         evas_object_map_enable_set(back, EINA_FALSE);
1249      }
1250    free(data);
1251 }
1252
1253 static void
1254 _transit_effect_flip_op(void *data, Elm_Transit *transit, double progress)
1255 {
1256    EINA_SAFETY_ON_NULL_RETURN(data);
1257    EINA_SAFETY_ON_NULL_RETURN(transit);
1258    Evas_Object *obj, *front, *back;
1259    int count, i;
1260    Elm_Transit_Effect_Flip *flip = data;
1261    Evas_Map *map;
1262    float degree;
1263    Evas_Coord x, y, w, h;
1264
1265    map = evas_map_new(4);
1266    if (!map) return;
1267
1268    if (flip->cw) degree = (float)(progress * 180);
1269    else degree = (float)(progress * -180);
1270
1271    count = eina_list_count(transit->objs);
1272    for (i = 0; i < (count - 1); i += 2)
1273      {
1274         Evas_Coord half_w, half_h;
1275
1276         front = eina_list_nth(transit->objs, i);
1277         back = eina_list_nth(transit->objs, i+1);
1278
1279         if ((degree < 90) && (degree > -90))
1280           {
1281              obj = front;
1282              if (front != back)
1283                {
1284                   evas_object_hide(back);
1285                   evas_object_show(front);
1286                }
1287           }
1288         else
1289           {
1290              obj = back;
1291              if (front != back)
1292                {
1293                   evas_object_hide(front);
1294                   evas_object_show(back);
1295                }
1296           }
1297
1298         evas_map_util_points_populate_from_object_full(map, obj, 0);
1299         evas_object_geometry_get(obj, &x, &y, &w, &h);
1300         half_w = (w / 2);
1301         half_h = (h / 2);
1302
1303         if (flip->axis == ELM_TRANSIT_EFFECT_FLIP_AXIS_Y)
1304           {
1305              if ((degree >= 90) || (degree <= -90))
1306                {
1307                   evas_map_point_image_uv_set(map, 0, w, 0);
1308                   evas_map_point_image_uv_set(map, 1, 0, 0);
1309                   evas_map_point_image_uv_set(map, 2, 0, h);
1310                   evas_map_point_image_uv_set(map, 3, w, h);
1311                }
1312              evas_map_util_3d_rotate(map, 0, degree,
1313                                      0, x + half_w, y + half_h, 0);
1314           }
1315         else
1316           {
1317              if ((degree >= 90) || (degree <= -90))
1318                {
1319                   evas_map_point_image_uv_set(map, 0, 0, h);
1320                   evas_map_point_image_uv_set(map, 1, w, h);
1321                   evas_map_point_image_uv_set(map, 2, w, 0);
1322                   evas_map_point_image_uv_set(map, 3, 0, 0);
1323                }
1324              evas_map_util_3d_rotate(map, degree,
1325                                      0, 0, x + half_w, y + half_h, 0);
1326           }
1327         evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, FOCAL);
1328         evas_object_map_enable_set(front, EINA_TRUE);
1329         evas_object_map_enable_set(back, EINA_TRUE);
1330         evas_object_map_set(obj, map);
1331      }
1332    evas_map_free(map);
1333 }
1334
1335 static void *
1336 _transit_effect_flip_context_new(Elm_Transit_Effect_Flip_Axis axis, Eina_Bool cw)
1337 {
1338    Elm_Transit_Effect_Flip *flip;
1339
1340    flip = ELM_NEW(Elm_Transit_Effect_Flip);
1341    if (!flip) return NULL;
1342
1343    flip->cw = cw;
1344    flip->axis = axis;
1345
1346    return flip;
1347 }
1348
1349 /**
1350  * Add the Flip Effect to Elm_Transit.
1351  *
1352  * @note This API is one of the facades. It creates flip effect context
1353  * and add it's required APIs to elm_transit_effect_add.
1354  * @note This effect is applied to each pair of objects in the order they are listed
1355  * in the transit list of objects. The first object in the pair will be the
1356  * "front" object and the second will be the "back" object.
1357  * @note If you change the set of objects in the transit with  elm_transit_object_add()
1358  * or elm_transit_object_remove(), the set of objects affected by this effect
1359  * will be changed too.
1360  *
1361  * @see elm_transit_effect_add()
1362  *
1363  * @param transit Transit object.
1364  * @param axis Flipping Axis(X or Y).
1365  * @param cw Flipping Direction. EINA_TRUE is clock-wise.
1366  * @return Flip effect context data.
1367  *
1368  * @ingroup Transit
1369  * @warning Is higher recommended just create a transit with this effect when
1370  * the window that the objects of the transit belongs has already been created.
1371  * This is because this effect needs the geometry information about the objects,
1372  * and if the window was not created yet, it can get a wrong information.
1373  * @warning Is not recommended remove or add an object after the transit begins
1374  * to run, because the order of the objects will be affected.
1375  */
1376 EAPI void *
1377 elm_transit_effect_flip_add(Elm_Transit *transit, Elm_Transit_Effect_Flip_Axis axis, Eina_Bool cw)
1378 {
1379    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
1380    void *effect_context = _transit_effect_flip_context_new(axis, cw);
1381
1382    if (!effect_context) return NULL;
1383    elm_transit_effect_add(transit,
1384                           _transit_effect_flip_op, effect_context,
1385                           _transit_effect_flip_context_free);
1386    return effect_context;
1387 }
1388
1389 ///////////////////////////////////////////////////////////////////////////////
1390 //ResizableFlip FX
1391 ///////////////////////////////////////////////////////////////////////////////
1392 typedef struct _Elm_Transit_Effect_Resizable_Flip Elm_Transit_Effect_ResizableFlip;
1393 typedef struct _Elm_Transit_Effect_Resizable_Flip_Node Elm_Transit_Effect_ResizableFlip_Node;
1394
1395 struct _Elm_Transit_Effect_Resizable_Flip_Node
1396 {
1397    Evas_Object *front;
1398    Evas_Object *back;
1399    struct _vector2d {
1400       float x, y;
1401    } from_pos, from_size, to_pos, to_size;
1402 };
1403
1404 struct _Elm_Transit_Effect_Resizable_Flip
1405 {
1406    Eina_List *nodes;
1407    Eina_Bool cw : 1;
1408    Elm_Transit_Effect_Flip_Axis axis;
1409 };
1410
1411 static void
1412 _resizable_flip_object_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1413 {
1414    Elm_Transit_Effect_ResizableFlip *resizable_flip = data;
1415    Eina_List *elist;
1416    Elm_Transit_Effect_ResizableFlip_Node *resizable_flip_node;
1417
1418    EINA_LIST_FOREACH(resizable_flip->nodes, elist, resizable_flip_node)
1419      {
1420         if (resizable_flip_node->front == obj)
1421            evas_object_event_callback_del(resizable_flip_node->back,
1422                                           EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb);
1423         else if (resizable_flip_node->back == obj)
1424            evas_object_event_callback_del(resizable_flip_node->front,
1425                                           EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb);
1426         else continue;
1427
1428         resizable_flip->nodes = eina_list_remove_list(resizable_flip->nodes,
1429                                                       elist);
1430         free(resizable_flip_node);
1431         break;
1432      }
1433 }
1434
1435 static Eina_List *
1436 _resizable_flip_nodes_build(Elm_Transit *transit, Elm_Transit_Effect_ResizableFlip *resizable_flip)
1437 {
1438    Elm_Transit_Effect_ResizableFlip_Node *resizable_flip_node;
1439    Eina_List *data_list = NULL;
1440    Evas_Coord front_x, front_y, front_w, front_h;
1441    Evas_Coord back_x, back_y, back_w, back_h;
1442    int i, count;
1443
1444    count = eina_list_count(transit->objs);
1445    for (i = 0; i < (count - 1); i += 2)
1446      {
1447         resizable_flip_node = ELM_NEW(Elm_Transit_Effect_ResizableFlip_Node);
1448         if (!resizable_flip_node)
1449           {
1450              eina_list_free(data_list);
1451              return NULL;
1452           }
1453
1454         resizable_flip_node->front = eina_list_nth(transit->objs, i);
1455         resizable_flip_node->back = eina_list_nth(transit->objs, i+1);
1456
1457         evas_object_geometry_get(resizable_flip_node->front,
1458                                  &front_x, &front_y, &front_w, &front_h);
1459         evas_object_geometry_get(resizable_flip_node->back,
1460                                  &back_x, &back_y, &back_w, &back_h);
1461
1462         resizable_flip_node->from_pos.x = front_x;
1463         resizable_flip_node->from_pos.y = front_y;
1464         resizable_flip_node->to_pos.x = back_x - front_x;
1465         resizable_flip_node->to_pos.y = back_y - front_y;
1466
1467         resizable_flip_node->from_size.x = front_w;
1468         resizable_flip_node->from_size.y = front_h;
1469         resizable_flip_node->to_size.x = back_w - front_w;
1470         resizable_flip_node->to_size.y = back_h - front_h;
1471
1472         data_list = eina_list_append(data_list, resizable_flip_node);
1473
1474         evas_object_event_callback_add(resizable_flip_node->back,
1475                                        EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb, resizable_flip);
1476         evas_object_event_callback_add(resizable_flip_node->front,
1477                                        EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb, resizable_flip);
1478      }
1479
1480    return data_list;
1481 }
1482
1483 static void
1484 _set_image_uv_by_axis_y(Evas_Map *map, Elm_Transit_Effect_ResizableFlip_Node *flip, float degree)
1485 {
1486    if ((degree >= 90) || (degree <= -90))
1487      {
1488         evas_map_point_image_uv_set(map, 0,
1489                                     (flip->from_size.x * 2) + flip->to_size.x,
1490                                     0);
1491         evas_map_point_image_uv_set(map, 1, 0, 0);
1492         evas_map_point_image_uv_set(map, 2, 0,
1493                                     (flip->from_size.y * 2) + flip->to_size.y);
1494         evas_map_point_image_uv_set(map, 3,
1495                                     (flip->from_size.x * 2) + flip->to_size.x,
1496                                     (flip->from_size.y * 2) + flip->to_size.y);
1497      }
1498    else
1499      {
1500         evas_map_point_image_uv_set(map, 0, 0, 0);
1501         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1502         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1503                                     flip->from_size.y);
1504         evas_map_point_image_uv_set(map, 3, 0, flip->from_size.y);
1505      }
1506 }
1507
1508 static void
1509 _set_image_uv_by_axis_x(Evas_Map *map, Elm_Transit_Effect_ResizableFlip_Node *flip, float degree)
1510 {
1511    if ((degree >= 90) || (degree <= -90))
1512      {
1513         evas_map_point_image_uv_set(map, 0, 0,
1514                                     (flip->from_size.y * 2) + flip->to_size.y);
1515         evas_map_point_image_uv_set(map, 1,
1516                                     (flip->from_size.x * 2) + flip->to_size.x,
1517                                     (flip->from_size.y * 2) + flip->to_size.y);
1518         evas_map_point_image_uv_set(map, 2,
1519                                     (flip->from_size.x * 2) + flip->to_size.x,
1520                                     0);
1521         evas_map_point_image_uv_set(map, 3, 0, 0);
1522      }
1523    else
1524      {
1525         evas_map_point_image_uv_set(map, 0, 0, 0);
1526         evas_map_point_image_uv_set(map, 1, flip->from_size.x, 0);
1527         evas_map_point_image_uv_set(map, 2, flip->from_size.x,
1528                                     flip->from_size.y);
1529         evas_map_point_image_uv_set(map, 3, 0, flip->from_size.y);
1530      }
1531 }
1532
1533 void
1534 _transit_effect_resizable_flip_context_free(void *data, Elm_Transit *transit __UNUSED__)
1535 {
1536    EINA_SAFETY_ON_NULL_RETURN(data);
1537
1538    Elm_Transit_Effect_ResizableFlip *resizable_flip = data;
1539    Eina_List *elist, *elist_next;
1540    Elm_Transit_Effect_ResizableFlip_Node *resizable_flip_node;
1541
1542    EINA_LIST_FOREACH_SAFE(resizable_flip->nodes,
1543                           elist, elist_next, resizable_flip_node)
1544      {
1545         evas_object_map_enable_set(resizable_flip_node->front, EINA_FALSE);
1546         evas_object_map_enable_set(resizable_flip_node->back, EINA_FALSE);
1547
1548         resizable_flip->nodes = eina_list_remove_list(resizable_flip->nodes,
1549                                                       elist);
1550
1551         evas_object_event_callback_del(resizable_flip_node->back,
1552                                        EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb);
1553         evas_object_event_callback_del(resizable_flip_node->front,
1554                                        EVAS_CALLBACK_DEL, _resizable_flip_object_del_cb);
1555         free(resizable_flip_node);
1556      }
1557    free(resizable_flip);
1558 }
1559
1560 void
1561 _transit_effect_resizable_flip_op(void *data, Elm_Transit *transit __UNUSED__, double progress)
1562 {
1563    EINA_SAFETY_ON_NULL_RETURN(data);
1564    Evas_Map *map;
1565    Evas_Object *obj;
1566    float x, y, w, h;
1567    float degree;
1568    Evas_Coord half_w, half_h;
1569    Elm_Transit_Effect_ResizableFlip *resizable_flip = data;
1570    Elm_Transit_Effect_ResizableFlip_Node *resizable_flip_node;
1571    Eina_List *elist;
1572
1573    map = evas_map_new(4);
1574    if (!map) return;
1575
1576    if (resizable_flip->cw) degree = (float)(progress * 180);
1577    else degree = (float)(progress * -180);
1578
1579    if (!resizable_flip->nodes)
1580       resizable_flip->nodes = _resizable_flip_nodes_build(transit,
1581                                                           resizable_flip);
1582
1583    EINA_LIST_FOREACH(resizable_flip->nodes, elist, resizable_flip_node)
1584      {
1585         if ((degree < 90) && (degree > -90))
1586           {
1587              obj = resizable_flip_node->front;
1588              if (resizable_flip_node->front != resizable_flip_node->back)
1589                {
1590                   evas_object_hide(resizable_flip_node->back);
1591                   evas_object_show(resizable_flip_node->front);
1592                }
1593           }
1594         else
1595           {
1596              obj = resizable_flip_node->back;
1597              if (resizable_flip_node->front != resizable_flip_node->back)
1598                {
1599                   evas_object_hide(resizable_flip_node->front);
1600                   evas_object_show(resizable_flip_node->back);
1601                }
1602           }
1603
1604         x = resizable_flip_node->from_pos.x +
1605            (resizable_flip_node->to_pos.x * progress);
1606         y = resizable_flip_node->from_pos.y +
1607            (resizable_flip_node->to_pos.y * progress);
1608         w = resizable_flip_node->from_size.x +
1609            (resizable_flip_node->to_size.x * progress);
1610         h = resizable_flip_node->from_size.y +
1611            (resizable_flip_node->to_size.y * progress);
1612         evas_map_point_coord_set(map, 0, x, y, 0);
1613         evas_map_point_coord_set(map, 1, x + w, y, 0);
1614         evas_map_point_coord_set(map, 2, x + w, y + h, 0);
1615         evas_map_point_coord_set(map, 3, x, y + h, 0);
1616
1617         half_w = (Evas_Coord)(w / 2);
1618         half_h = (Evas_Coord)(h / 2);
1619
1620         if (resizable_flip->axis == ELM_TRANSIT_EFFECT_FLIP_AXIS_Y)
1621           {
1622              _set_image_uv_by_axis_y(map, resizable_flip_node, degree);
1623              evas_map_util_3d_rotate(map, 0, degree,
1624                                      0, x + half_w, y + half_h, 0);
1625           }
1626         else
1627           {
1628              _set_image_uv_by_axis_x(map, resizable_flip_node, degree);
1629              evas_map_util_3d_rotate(map, degree, 0,
1630                                      0, x + half_w, y + half_h, 0);
1631           }
1632
1633         evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, FOCAL);
1634         evas_object_map_enable_set(resizable_flip_node->front, EINA_TRUE);
1635         evas_object_map_enable_set(resizable_flip_node->back, EINA_TRUE);
1636         evas_object_map_set(obj, map);
1637      }
1638    evas_map_free(map);
1639 }
1640
1641 static void *
1642 _transit_effect_resizable_flip_context_new(Elm_Transit_Effect_Flip_Axis axis, Eina_Bool cw)
1643 {
1644    Elm_Transit_Effect_ResizableFlip *resizable_flip;
1645
1646    resizable_flip = ELM_NEW(Elm_Transit_Effect_ResizableFlip);
1647    if (!resizable_flip) return NULL;
1648
1649    resizable_flip->cw = cw;
1650    resizable_flip->axis = axis;
1651
1652    return resizable_flip;
1653 }
1654
1655 /**
1656  * Add the Resizable Flip Effect to Elm_Transit.
1657  *
1658  * @note This API is one of the facades. It creates resizable flip effect context
1659  * and add it's required APIs to elm_transit_effect_add.
1660  * @note This effect is applied to each pair of objects in the order they are listed
1661  * in the transit list of objects. The first object in the pair will be the
1662  * "front" object and the second will be the "back" object.
1663  * @note When this function is called, it gets the current objects in
1664  * the transit, that is, elm_transit_object_remove() and elm_transit_object_add()
1665  * will not cause any changes in the set of objects that this effect is being
1666  * applied.
1667  *
1668  * @see elm_transit_effect_add()
1669  *
1670  * @param transit Transit object.
1671  * @param axis Flipping Axis(X or Y).
1672  * @param cw Flipping Direction. EINA_TRUE is clock-wise.
1673  * @return Resizable flip effect context data.
1674  *
1675  * @ingroup Transit
1676  * @warning Is higher recommended just create a transit with this effect when
1677  * the window that the objects of the transit belongs has already been created.
1678  * This is because this effect needs the geometry information about the objects,
1679  * and if the window was not created yet, it can get a wrong information.
1680  * @warning Is not recommended remove or add an object after the transit begins
1681  * to run, because the order of the objects will be affected.
1682  */
1683 EAPI void *
1684 elm_transit_effect_resizable_flip_add(Elm_Transit *transit, Elm_Transit_Effect_Flip_Axis axis, Eina_Bool cw)
1685 {
1686    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
1687    void *effect_context = _transit_effect_resizable_flip_context_new(axis, cw);
1688
1689    if (!effect_context) return NULL;
1690    elm_transit_effect_add(transit,
1691                           _transit_effect_resizable_flip_op, effect_context,
1692                           _transit_effect_resizable_flip_context_free);
1693    return effect_context;
1694 }
1695
1696
1697 ///////////////////////////////////////////////////////////////////////////////
1698 //Wipe FX
1699 ///////////////////////////////////////////////////////////////////////////////
1700 typedef struct _Elm_Transit_Effect_Wipe Elm_Transit_Effect_Wipe;
1701
1702 struct _Elm_Transit_Effect_Wipe
1703 {
1704    Elm_Transit_Effect_Wipe_Type type;
1705    Elm_Transit_Effect_Wipe_Dir dir;
1706 };
1707
1708 static void
1709 _elm_fx_wipe_hide(Evas_Map * map, Elm_Transit_Effect_Wipe_Dir dir, float x, float y, float w, float h, float progress)
1710 {
1711    float w2, h2;
1712
1713    switch (dir)
1714      {
1715       case ELM_TRANSIT_EFFECT_WIPE_DIR_LEFT:
1716          w2 = w - (w * progress);
1717          h2 = (y + h);
1718          evas_map_point_image_uv_set(map, 0, 0, 0);
1719          evas_map_point_image_uv_set(map, 1, w2, 0);
1720          evas_map_point_image_uv_set(map, 2, w2, h);
1721          evas_map_point_image_uv_set(map, 3, 0, h);
1722          evas_map_point_coord_set(map, 0, x, y, 0);
1723          evas_map_point_coord_set(map, 1, x + w2, y, 0);
1724          evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1725          evas_map_point_coord_set(map, 3, x, h2, 0);
1726          break;
1727       case ELM_TRANSIT_EFFECT_WIPE_DIR_RIGHT:
1728          w2 = (w * progress);
1729          h2 = (y + h);
1730          evas_map_point_image_uv_set(map, 0, w2, 0);
1731          evas_map_point_image_uv_set(map, 1, w, 0);
1732          evas_map_point_image_uv_set(map, 2, w, h);
1733          evas_map_point_image_uv_set(map, 3, w2, h);
1734          evas_map_point_coord_set(map, 0, x + w2, y, 0);
1735          evas_map_point_coord_set(map, 1, x + w, y, 0);
1736          evas_map_point_coord_set(map, 2, x + w, h2, 0);
1737          evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1738          break;
1739       case ELM_TRANSIT_EFFECT_WIPE_DIR_UP:
1740          w2 = (x + w);
1741          h2 = h - (h * progress);
1742          evas_map_point_image_uv_set(map, 0, 0, 0);
1743          evas_map_point_image_uv_set(map, 1, w, 0);
1744          evas_map_point_image_uv_set(map, 2, w, h2);
1745          evas_map_point_image_uv_set(map, 3, 0, h2);
1746          evas_map_point_coord_set(map, 0, x, y, 0);
1747          evas_map_point_coord_set(map, 1, w2, y, 0);
1748          evas_map_point_coord_set(map, 2, w2, y+h2, 0);
1749          evas_map_point_coord_set(map, 3, x, y+h2, 0);
1750          break;
1751       case ELM_TRANSIT_EFFECT_WIPE_DIR_DOWN:
1752          w2 = (x + w);
1753          h2 = (h * progress);
1754          evas_map_point_image_uv_set(map, 0, 0, h2);
1755          evas_map_point_image_uv_set(map, 1, w, h2);
1756          evas_map_point_image_uv_set(map, 2, w, h);
1757          evas_map_point_image_uv_set(map, 3, 0, h);
1758          evas_map_point_coord_set(map, 0, x, y + h2, 0);
1759          evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1760          evas_map_point_coord_set(map, 2, w2, y + h, 0);
1761          evas_map_point_coord_set(map, 3, x, y + h, 0);
1762          break;
1763       default:
1764          break;
1765      }
1766    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, FOCAL);
1767 }
1768
1769 static void
1770 _elm_fx_wipe_show(Evas_Map *map, Elm_Transit_Effect_Wipe_Dir dir, float x, float y, float w, float h, float progress)
1771 {
1772    float w2, h2;
1773
1774    switch (dir)
1775      {
1776       case ELM_TRANSIT_EFFECT_WIPE_DIR_LEFT:
1777          w2 = (w - (w * progress));
1778          h2 = (y + h);
1779          evas_map_point_image_uv_set(map, 0, w2, 0);
1780          evas_map_point_image_uv_set(map, 1, w, 0);
1781          evas_map_point_image_uv_set(map, 2, w, h);
1782          evas_map_point_image_uv_set(map, 3, w2, h);
1783          evas_map_point_coord_set(map, 0, x + w2, y, 0);
1784          evas_map_point_coord_set(map, 1, w, y, 0);
1785          evas_map_point_coord_set(map, 2, w, h2, 0);
1786          evas_map_point_coord_set(map, 3, x + w2, h2, 0);
1787          break;
1788       case ELM_TRANSIT_EFFECT_WIPE_DIR_RIGHT:
1789          w2 = (w * progress);
1790          h2 = (y + h);
1791          evas_map_point_image_uv_set(map, 0, 0, 0);
1792          evas_map_point_image_uv_set(map, 1, w2, 0);
1793          evas_map_point_image_uv_set(map, 2, w2, h);
1794          evas_map_point_image_uv_set(map, 3, 0, h);
1795          evas_map_point_coord_set(map, 0, x, y, 0);
1796          evas_map_point_coord_set(map, 1, x + w2, y, 0);
1797          evas_map_point_coord_set(map, 2, x + w2, h2, 0);
1798          evas_map_point_coord_set(map, 3, x, h2, 0);
1799          break;
1800       case ELM_TRANSIT_EFFECT_WIPE_DIR_UP:
1801          w2 = (x + w);
1802          h2 = (h - (h * progress));
1803          evas_map_point_image_uv_set(map, 0, 0, h2);
1804          evas_map_point_image_uv_set(map, 1, w, h2);
1805          evas_map_point_image_uv_set(map, 2, w, h);
1806          evas_map_point_image_uv_set(map, 3, 0, h);
1807          evas_map_point_coord_set(map, 0, x, y + h2, 0);
1808          evas_map_point_coord_set(map, 1, w2, y + h2, 0);
1809          evas_map_point_coord_set(map, 2, w2, y + h, 0);
1810          evas_map_point_coord_set(map, 3, x, y + h, 0);
1811          break;
1812       case ELM_TRANSIT_EFFECT_WIPE_DIR_DOWN:
1813          w2 = (x + w);
1814          h2 = (h * progress);
1815          evas_map_point_image_uv_set(map, 0, 0, 0);
1816          evas_map_point_image_uv_set(map, 1, w, 0);
1817          evas_map_point_image_uv_set(map, 2, w, h2);
1818          evas_map_point_image_uv_set(map, 3, 0, h2);
1819          evas_map_point_coord_set(map, 0, x, y, 0);
1820          evas_map_point_coord_set(map, 1, w2, y, 0);
1821          evas_map_point_coord_set(map, 2, w2, y + h2, 0);
1822          evas_map_point_coord_set(map, 3, x, y + h2, 0);
1823          break;
1824       default:
1825          break;
1826      }
1827    evas_map_util_3d_perspective(map, x + (w / 2), y + (h / 2), 0, FOCAL);
1828 }
1829
1830 static void
1831 _transit_effect_wipe_context_free(void *data, Elm_Transit *transit)
1832 {
1833    EINA_SAFETY_ON_NULL_RETURN(data);
1834    EINA_SAFETY_ON_NULL_RETURN(transit);
1835    Eina_List *elist;
1836    Evas_Object *obj;
1837    Elm_Transit_Effect_Wipe *wipe = data;
1838    Eina_Bool reverse = elm_transit_auto_reverse_get(transit);
1839
1840    EINA_LIST_FOREACH(transit->objs, elist, obj)
1841      {
1842         if ((wipe->type == ELM_TRANSIT_EFFECT_WIPE_TYPE_SHOW && !reverse)
1843             || (wipe->type == ELM_TRANSIT_EFFECT_WIPE_TYPE_HIDE && reverse))
1844            evas_object_show(obj);
1845         else evas_object_hide(obj);
1846         evas_object_map_enable_set(obj, EINA_FALSE);
1847      }
1848
1849    free(wipe);
1850 }
1851
1852 static void
1853 _transit_effect_wipe_op(void *data, Elm_Transit *transit, double progress)
1854 {
1855    EINA_SAFETY_ON_NULL_RETURN(data);
1856    EINA_SAFETY_ON_NULL_RETURN(transit);
1857    Elm_Transit_Effect_Wipe *wipe = data;
1858    Evas_Map *map;
1859    Evas_Coord _x, _y, _w, _h;
1860    Eina_List *elist;
1861    Evas_Object *obj;
1862
1863    map = evas_map_new(4);
1864    if (!map) return;
1865
1866    EINA_LIST_FOREACH(transit->objs, elist, obj)
1867      {
1868         evas_object_geometry_get(obj, &_x, &_y, &_w, &_h);
1869
1870         if (wipe->type == ELM_TRANSIT_EFFECT_WIPE_TYPE_SHOW)
1871            _elm_fx_wipe_show(map, wipe->dir, _x, _y, _w, _h, (float)progress);
1872         else
1873            _elm_fx_wipe_hide(map, wipe->dir, _x, _y, _w, _h, (float)progress);
1874
1875         evas_object_map_enable_set(obj, EINA_TRUE);
1876         evas_object_map_set(obj, map);
1877      }
1878    evas_map_free(map);
1879 }
1880
1881 static void *
1882 _transit_effect_wipe_context_new(Elm_Transit_Effect_Wipe_Type type, Elm_Transit_Effect_Wipe_Dir dir)
1883 {
1884    Elm_Transit_Effect_Wipe *wipe;
1885
1886    wipe = ELM_NEW(Elm_Transit_Effect_Wipe);
1887    if (!wipe) return NULL;
1888
1889    wipe->type = type;
1890    wipe->dir = dir;
1891
1892    return wipe;
1893 }
1894
1895 /**
1896  * Add the Wipe Effect to Elm_Transit.
1897  *
1898  * @note This API is one of the facades. It creates wipe effect context
1899  * and add it's required APIs to elm_transit_effect_add.
1900  * @note This effect will be applied to the objects that are in the transit,
1901  * If you change the set of objects in the transit with  elm_transit_object_add()
1902  * or elm_transit_object_remove(), the set of objects affected by this effect
1903  * will be changed too.
1904  *
1905  * @see elm_transit_effect_add()
1906  *
1907  * @param transit Transit object.
1908  * @param type Wipe type. Hide or show.
1909  * @param dir Wipe Direction.
1910  * @return Wipe effect context data.
1911  *
1912  * @ingroup Transit
1913  * @warning Is higher recommended just create a transit with this effect when
1914  * the window that the objects of the transit belongs has already been created.
1915  * This is because this effect needs the geometry information about the objects,
1916  * and if the window was not created yet, it can get a wrong information.
1917  * @warning Is not recommended remove or add an object after the transit begins
1918  * to run, because the order of the objects will be affected.
1919  */
1920 EAPI void *
1921 elm_transit_effect_wipe_add(Elm_Transit *transit, Elm_Transit_Effect_Wipe_Type type, Elm_Transit_Effect_Wipe_Dir dir)
1922 {
1923    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
1924    void *effect_context = _transit_effect_wipe_context_new(type, dir);
1925
1926    if (!effect_context) return NULL;
1927    elm_transit_effect_add(transit,
1928                           _transit_effect_wipe_op, effect_context,
1929                           _transit_effect_wipe_context_free);
1930    return effect_context;
1931 }
1932
1933
1934 ///////////////////////////////////////////////////////////////////////////////
1935 //Color FX
1936 ///////////////////////////////////////////////////////////////////////////////
1937 typedef struct _Elm_Transit_Effect_Color Elm_Transit_Effect_Color;
1938
1939 struct _Elm_Transit_Effect_Color
1940 {
1941    struct _unsigned_color {
1942       unsigned int r, g, b, a;
1943    } from;
1944    struct _signed_color {
1945       int r, g, b, a;
1946    } to;
1947 };
1948
1949 static void
1950 _transit_effect_color_context_free(void *data, Elm_Transit *transit __UNUSED__)
1951 {
1952    free(data);
1953 }
1954
1955 static void
1956 _transit_effect_color_op(void *data, Elm_Transit *transit, double progress)
1957 {
1958    EINA_SAFETY_ON_NULL_RETURN(data);
1959    EINA_SAFETY_ON_NULL_RETURN(transit);
1960    Elm_Transit_Effect_Color *color = data;
1961    Evas_Object *obj;
1962    Eina_List *elist;
1963    unsigned int r, g, b, a;
1964
1965    r = (color->from.r + (int)((float)color->to.r * progress));
1966    g = (color->from.g + (int)((float)color->to.g * progress));
1967    b = (color->from.b + (int)((float)color->to.b * progress));
1968    a = (color->from.a + (int)((float)color->to.a * progress));
1969
1970    EINA_LIST_FOREACH(transit->objs, elist, obj)
1971       evas_object_color_set(obj, r, g, b, a);
1972 }
1973
1974 static void *
1975 _transit_effect_color_context_new(unsigned int from_r, unsigned int from_g, unsigned int from_b, unsigned int from_a, unsigned int to_r, unsigned int to_g, unsigned int to_b, unsigned int to_a)
1976 {
1977    Elm_Transit_Effect_Color *color;
1978
1979    color = ELM_NEW(Elm_Transit_Effect_Color);
1980    if (!color) return NULL;
1981
1982    color->from.r = from_r;
1983    color->from.g = from_g;
1984    color->from.b = from_b;
1985    color->from.a = from_a;
1986    color->to.r = to_r - from_r;
1987    color->to.g = to_g - from_g;
1988    color->to.b = to_b - from_b;
1989    color->to.a = to_a - from_a;
1990
1991    return color;
1992 }
1993
1994 /**
1995  * Add the Color Effect to Elm_Transit.
1996  *
1997  * @note This API is one of the facades. It creates color effect context
1998  * and add it's required APIs to elm_transit_effect_add.
1999  * @note This effect will be applied to the objects that are in the transit,
2000  * If you change the set of objects in the transit with  elm_transit_object_add()
2001  * or elm_transit_object_remove(), the set of objects affected by this effect
2002  * will be changed too.
2003  *
2004  * @see elm_transit_effect_add()
2005  *
2006  * @param transit        Transit object.
2007  * @param  from_r        RGB R when effect begins.
2008  * @param  from_g        RGB G when effect begins.
2009  * @param  from_b        RGB B when effect begins.
2010  * @param  from_a        RGB A when effect begins.
2011  * @param  to_r          RGB R when effect ends.
2012  * @param  to_g          RGB G when effect ends.
2013  * @param  to_b          RGB B when effect ends.
2014  * @param  to_a          RGB A when effect ends.
2015  * @return               Color effect context data.
2016  *
2017  * @ingroup Transit
2018  */
2019 EAPI void *
2020 elm_transit_effect_color_add(Elm_Transit *transit, unsigned int from_r, unsigned int from_g, unsigned int from_b, unsigned int from_a, unsigned int to_r, unsigned int to_g, unsigned int to_b, unsigned int to_a)
2021 {
2022    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
2023    void *effect_context = _transit_effect_color_context_new(from_r, from_g, from_b, from_a, to_r, to_g, to_b, to_a);
2024
2025    if (!effect_context) return NULL;
2026    elm_transit_effect_add(transit,
2027                           _transit_effect_color_op, effect_context,
2028                           _transit_effect_color_context_free);
2029    return effect_context;
2030 }
2031
2032 ///////////////////////////////////////////////////////////////////////////////
2033 //Fade FX
2034 ///////////////////////////////////////////////////////////////////////////////
2035 typedef struct _Elm_Transit_Effect_Fade Elm_Transit_Effect_Fade;
2036 typedef struct _Elm_Transit_Effect_Fade_Node Elm_Transit_Effect_Fade_Node;
2037
2038 struct _Elm_Transit_Effect_Fade_Node
2039 {
2040    Evas_Object *before;
2041    Evas_Object *after;
2042    struct _signed_color before_color, after_color;
2043    int before_alpha;
2044    int after_alpha;
2045    Eina_Bool inversed : 1;
2046 };
2047
2048 struct _Elm_Transit_Effect_Fade
2049 {
2050    Eina_List *nodes;
2051 };
2052
2053 static void
2054 _fade_object_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
2055 {
2056    Elm_Transit_Effect_Fade *fade = data;
2057    Eina_List *elist;
2058    Elm_Transit_Effect_Fade_Node *fade_node;
2059
2060    EINA_LIST_FOREACH(fade->nodes, elist, fade_node)
2061      {
2062         if (fade_node->before == obj)
2063            evas_object_event_callback_del(fade_node->after,
2064                                           EVAS_CALLBACK_DEL, _fade_object_del_cb);
2065         else if (fade_node->after == obj)
2066            evas_object_event_callback_del(fade_node->before,
2067                                           EVAS_CALLBACK_DEL, _fade_object_del_cb);
2068         else continue;
2069
2070         fade->nodes = eina_list_remove_list(fade->nodes, elist);
2071         free(fade_node);
2072         break;
2073      }
2074 }
2075
2076 static Eina_List *
2077 _fade_nodes_build(Elm_Transit *transit, Elm_Transit_Effect_Fade *fade_data)
2078 {
2079    Elm_Transit_Effect_Fade_Node *fade;
2080    Eina_List *data_list = NULL;
2081    int i, count;
2082
2083    count = eina_list_count(transit->objs);
2084    for (i = 0; i < (count - 1); i += 2)
2085      {
2086         fade = ELM_NEW(Elm_Transit_Effect_Fade_Node);
2087         if (!fade)
2088           {
2089              eina_list_free(data_list);
2090              return NULL;
2091           }
2092
2093         fade->before = eina_list_nth(transit->objs, i);
2094         fade->after = eina_list_nth(transit->objs, i+1);
2095
2096         evas_object_color_get(fade->before,
2097                               &fade->before_color.r, &fade->before_color.g,
2098                               &fade->before_color.b, &fade->before_color.a);
2099         evas_object_color_get(fade->after,
2100                               &fade->after_color.r, &fade->after_color.g,
2101                               &fade->after_color.b, &fade->after_color.a);
2102
2103         fade->before_alpha = (255 - fade->before_color.a);
2104         fade->after_alpha = (255 - fade->after_color.a);
2105
2106         data_list = eina_list_append(data_list, fade);
2107
2108         evas_object_event_callback_add(fade->before,
2109                                        EVAS_CALLBACK_DEL, _fade_object_del_cb, fade_data);
2110         evas_object_event_callback_add(fade->after,
2111                                        EVAS_CALLBACK_DEL, _fade_object_del_cb, fade_data);
2112      }
2113    return data_list;
2114 }
2115
2116 static void
2117 _transit_effect_fade_context_free(void *data, Elm_Transit *transit __UNUSED__)
2118 {
2119    EINA_SAFETY_ON_NULL_RETURN(data);
2120    Elm_Transit_Effect_Fade *fade = data;
2121    Elm_Transit_Effect_Fade_Node *fade_node;
2122    Eina_List *elist, *elist_next;
2123
2124    EINA_LIST_FOREACH_SAFE(fade->nodes, elist, elist_next, fade_node)
2125      {
2126         evas_object_color_set(fade_node->before, fade_node->before_color.r,
2127                               fade_node->before_color.g,
2128                               fade_node->before_color.b,
2129                               fade_node->before_color.a);
2130         evas_object_color_set(fade_node->after, fade_node->after_color.r,
2131                               fade_node->after_color.g,
2132                               fade_node->after_color.b,
2133                               fade_node->after_color.a);
2134
2135         fade->nodes = eina_list_remove_list(fade->nodes, elist);
2136         evas_object_event_callback_del(fade_node->before,
2137                                        EVAS_CALLBACK_DEL, _fade_object_del_cb);
2138         evas_object_event_callback_del(fade_node->after,
2139                                        EVAS_CALLBACK_DEL, _fade_object_del_cb);
2140         free(fade_node);
2141      }
2142
2143    free(fade);
2144 }
2145
2146 static void
2147 _transit_effect_fade_op(void *data, Elm_Transit *transit __UNUSED__, double progress)
2148 {
2149    EINA_SAFETY_ON_NULL_RETURN(data);
2150    Elm_Transit_Effect_Fade *fade = data;
2151    Eina_List *elist;
2152    Elm_Transit_Effect_Fade_Node *fade_node;
2153    float _progress;
2154
2155    if (!fade->nodes)
2156       fade->nodes = _fade_nodes_build(transit, fade);
2157
2158    EINA_LIST_FOREACH(fade->nodes, elist, fade_node)
2159      {
2160         if (progress < 0.5)
2161           {
2162              if (!fade_node->inversed)
2163                {
2164                   evas_object_hide(fade_node->after);
2165                   evas_object_show(fade_node->before);
2166                   fade_node->inversed = EINA_TRUE;
2167                }
2168
2169              _progress = (1 - (progress * 2));
2170
2171              evas_object_color_set(fade_node->before,
2172                                    fade_node->before_color.r * _progress,
2173                                    fade_node->before_color.g * _progress,
2174                                    fade_node->before_color.b * _progress,
2175                                    fade_node->before_color.a +
2176                                    fade_node->before_alpha * (1 - _progress));
2177           }
2178         else
2179           {
2180              if (fade_node->inversed)
2181                {
2182                   evas_object_hide(fade_node->before);
2183                   evas_object_show(fade_node->after);
2184                   fade_node->inversed = EINA_FALSE;
2185                }
2186
2187              _progress = ((progress - 0.5) * 2);
2188
2189              evas_object_color_set(fade_node->after,
2190                                    fade_node->after_color.r * _progress,
2191                                    fade_node->after_color.g * _progress,
2192                                    fade_node->after_color.b * _progress,
2193                                    fade_node->after_color.a +
2194                                    fade_node->after_alpha * (1 - _progress));
2195           }
2196      }
2197 }
2198
2199 static void *
2200 _transit_effect_fade_context_new(void)
2201 {
2202    Elm_Transit_Effect_Fade *fade;
2203    fade = ELM_NEW(Elm_Transit_Effect_Fade);
2204    if (!fade) return NULL;
2205    return fade;
2206 }
2207
2208 /**
2209  * Add the Fade Effect to Elm_Transit.
2210  *
2211  * @note This API is one of the facades. It creates fade effect context
2212  * and add it's required APIs to elm_transit_effect_add.
2213  * @note This effect is applied to each pair of objects in the order they are listed
2214  * in the transit list of objects. The first object in the pair will be the
2215  * "before" object and the second will be the "after" object.
2216  * @note When this function is called, it gets the current objects in
2217  * the transit, that is, elm_transit_object_remove() and elm_transit_object_add()
2218  * will not cause any changes in the set of objects that this effect is being
2219  * applied.
2220  *
2221  * @see elm_transit_effect_add()
2222  *
2223  * @param transit Transit object.
2224  * @return Fade effect context data.
2225  *
2226  * @ingroup Transit
2227  * @warning Is higher recommended just create a transit with this effect when
2228  * the window that the objects of the transit belongs has already been created.
2229  * This is because this effect needs the color information about the objects,
2230  * and if the window was not created yet, it can get a wrong information.
2231  * @warning Is not recommended remove or add an object after the transit begins
2232  * to run, because the order of the objects will be affected.
2233  */
2234 EAPI void *
2235 elm_transit_effect_fade_add(Elm_Transit *transit)
2236 {
2237    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
2238
2239    void *effect_context = _transit_effect_fade_context_new();
2240    if (!effect_context) return NULL;
2241    elm_transit_effect_add(transit,
2242                           _transit_effect_fade_op, effect_context,
2243                           _transit_effect_fade_context_free);
2244    return effect_context;
2245 }
2246
2247
2248 ///////////////////////////////////////////////////////////////////////////////
2249 //Blend FX
2250 ///////////////////////////////////////////////////////////////////////////////
2251 typedef struct _Elm_Transit_Effect_Blend Elm_Transit_Effect_Blend;
2252 typedef struct _Elm_Transit_Effect_Blend_Node Elm_Transit_Effect_Blend_Node;
2253
2254 struct _Elm_Transit_Effect_Blend_Node
2255 {
2256    Evas_Object *before;
2257    Evas_Object *after;
2258    struct _signed_color from, to;
2259 };
2260
2261 struct _Elm_Transit_Effect_Blend
2262 {
2263    Eina_List *nodes;
2264 };
2265
2266 static void
2267 _blend_object_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
2268 {
2269    Elm_Transit_Effect_Blend *blend = data;
2270    Eina_List *elist;
2271    Elm_Transit_Effect_Blend_Node *blend_node;
2272
2273    EINA_LIST_FOREACH(blend->nodes, elist, blend_node)
2274      {
2275         if (blend_node->after == obj)
2276            evas_object_event_callback_del(blend_node->before,
2277                                           EVAS_CALLBACK_DEL, _blend_object_del_cb);
2278         else if (blend_node->before == obj)
2279            evas_object_event_callback_del(blend_node->after,
2280                                           EVAS_CALLBACK_DEL, _blend_object_del_cb);
2281         else continue;
2282
2283         blend->nodes = eina_list_remove_list(blend->nodes, elist);
2284         free(blend_node);
2285         break;
2286      }
2287 }
2288
2289 static Eina_List *
2290 _blend_nodes_build(Elm_Transit *transit, Elm_Transit_Effect_Blend *blend)
2291 {
2292    Elm_Transit_Effect_Blend_Node *blend_node;
2293    Eina_List *data_list = NULL;
2294    int i, count;
2295
2296    count = eina_list_count(transit->objs);
2297    for (i = 0; i < (count - 1); i += 2)
2298      {
2299         blend_node = ELM_NEW(Elm_Transit_Effect_Blend_Node);
2300         if (!blend_node)
2301           {
2302              eina_list_free(data_list);
2303              return NULL;
2304           }
2305
2306         blend_node->before = eina_list_nth(transit->objs, i);
2307         blend_node->after = eina_list_nth(transit->objs, i + 1);
2308         evas_object_show(blend_node->before);
2309         evas_object_show(blend_node->after);
2310
2311         evas_object_color_get(blend_node->before, &blend_node->from.r,
2312                               &blend_node->from.g, &blend_node->from.b,
2313                               &blend_node->from.a);
2314         evas_object_color_get(blend_node->after, &blend_node->to.r,
2315                               &blend_node->to.g, &blend_node->to.b,
2316                               &blend_node->to.a);
2317
2318         data_list = eina_list_append(data_list, blend_node);
2319
2320         evas_object_event_callback_add(blend_node->before,
2321                                        EVAS_CALLBACK_DEL, _blend_object_del_cb, blend);
2322         evas_object_event_callback_add(blend_node->after,
2323                                        EVAS_CALLBACK_DEL, _blend_object_del_cb, blend);
2324      }
2325    return data_list;
2326 }
2327
2328 void
2329 _transit_effect_blend_context_free(void *data, Elm_Transit *transit __UNUSED__)
2330 {
2331    EINA_SAFETY_ON_NULL_RETURN(data);
2332    Elm_Transit_Effect_Blend *blend = data;
2333    Elm_Transit_Effect_Blend_Node *blend_node;
2334    Eina_List *elist, *elist_next;
2335
2336    EINA_LIST_FOREACH_SAFE(blend->nodes, elist, elist_next, blend_node)
2337      {
2338         evas_object_color_set(blend_node->before,
2339                               blend_node->from.r, blend_node->from.g,
2340                               blend_node->from.b, blend_node->from.a);
2341         evas_object_color_set(blend_node->after, blend_node->to.r,
2342                               blend_node->to.g, blend_node->to.b,
2343                               blend_node->to.a);
2344
2345         if (elm_transit_auto_reverse_get(transit))
2346            evas_object_hide(blend_node->after);
2347         else
2348            evas_object_hide(blend_node->before);
2349
2350         blend->nodes = eina_list_remove_list(blend->nodes, elist);
2351
2352         evas_object_event_callback_del(blend_node->before,
2353                                        EVAS_CALLBACK_DEL, _blend_object_del_cb);
2354         evas_object_event_callback_del(blend_node->after,
2355                                        EVAS_CALLBACK_DEL, _blend_object_del_cb);
2356         free(blend_node);
2357      }
2358    free(data);
2359 }
2360
2361 void
2362 _transit_effect_blend_op(void *data, Elm_Transit *transit, double progress)
2363 {
2364    EINA_SAFETY_ON_NULL_RETURN(data);
2365    EINA_SAFETY_ON_NULL_RETURN(transit);
2366    Elm_Transit_Effect_Blend *blend = data;
2367    Elm_Transit_Effect_Blend_Node *blend_node;
2368    Eina_List *elist;
2369
2370    if (!blend->nodes) blend->nodes = _blend_nodes_build(transit, blend);
2371
2372    EINA_LIST_FOREACH(blend->nodes, elist, blend_node)
2373      {
2374         evas_object_color_set(blend_node->before,
2375                               (int)(blend_node->from.r * (1 - progress)),
2376                               (int)(blend_node->from.g * (1 - progress)),
2377                               (int)(blend_node->from.b * (1 - progress)),
2378                               (int)(blend_node->from.a * (1 - progress)));
2379         evas_object_color_set(blend_node->after,
2380                               (int)(blend_node->to.r * progress),
2381                               (int)(blend_node->to.g * progress),
2382                               (int)(blend_node->to.b * progress),
2383                               (int)(blend_node->to.a * progress));
2384      }
2385 }
2386
2387 static void *
2388 _transit_effect_blend_context_new(void)
2389 {
2390    Elm_Transit_Effect_Blend *blend;
2391
2392    blend = ELM_NEW(Elm_Transit_Effect_Blend);
2393    if (!blend) return NULL;
2394    return blend;
2395 }
2396
2397 /**
2398  * Add the Blend Effect to Elm_Transit.
2399  *
2400  * @note This API is one of the facades. It creates blend effect context
2401  * and add it's required APIs to elm_transit_effect_add.
2402  * @note This effect is applied to each pair of objects in the order they are listed
2403  * in the transit list of objects. The first object in the pair will be the
2404  * "before" object and the second will be the "after" object.
2405  * @note When this function be called, it gets the current objects in
2406  * the transit, that is, elm_transit_object_remove() and elm_transit_object_add()
2407  * will not cause any changes in the set of objects that this effect is being
2408  * applied.
2409  *
2410  * @see elm_transit_effect_add()
2411  *
2412  * @param transit Transit object.
2413  * @return Blend effect context data.
2414  *
2415  * @ingroup Transit
2416  * @warning Is higher recommended just create a transit with this effect when
2417  * the window that the objects of the transit belongs has already been created.
2418  * This is because this effect needs the color information about the objects,
2419  * and if the window was not created yet, it can get a wrong information.
2420  * @warning Is not recommended remove or add an object after the transit begins
2421  * to run, because the order of the objects will be affected.
2422  */
2423 EAPI void *
2424 elm_transit_effect_blend_add(Elm_Transit *transit)
2425 {
2426    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
2427    void *effect_context = _transit_effect_blend_context_new();
2428
2429    if (!effect_context) return NULL;
2430    elm_transit_effect_add(transit,
2431                           _transit_effect_blend_op, effect_context,
2432                           _transit_effect_blend_context_free);
2433    return effect_context;
2434 }
2435
2436
2437 ///////////////////////////////////////////////////////////////////////////////
2438 //Rotation FX
2439 ///////////////////////////////////////////////////////////////////////////////
2440 typedef struct _Elm_Transit_Effect_Rotation Elm_Transit_Effect_Rotation;
2441
2442 struct _Elm_Transit_Effect_Rotation
2443 {
2444    float from, to;
2445 };
2446
2447 static void
2448 _transit_effect_rotation_context_free(void *data, Elm_Transit *transit __UNUSED__)
2449 {
2450    free(data);
2451 }
2452
2453 static void
2454 _transit_effect_rotation_op(void *data, Elm_Transit *transit, double progress)
2455 {
2456    EINA_SAFETY_ON_NULL_RETURN(data);
2457    EINA_SAFETY_ON_NULL_RETURN(transit);
2458    Elm_Transit_Effect_Rotation *rotation = data;
2459    Evas_Map *map;
2460    Evas_Coord x, y, w, h;
2461    float degree;
2462    float half_w, half_h;
2463    Eina_List *elist;
2464    Evas_Object *obj;
2465
2466    map = evas_map_new(4);
2467    if (!map) return;
2468
2469    EINA_LIST_FOREACH(transit->objs, elist, obj)
2470      {
2471         evas_map_util_points_populate_from_object_full(map, obj, 0);
2472         degree = rotation->from + (float)(progress * rotation->to);
2473
2474         evas_object_geometry_get(obj, &x, &y, &w, &h);
2475
2476         half_w = (float)w * 0.5;
2477         half_h = (float)h * 0.5;
2478
2479         evas_map_util_3d_rotate(map, 0, 0, degree, x + half_w, y + half_h, 0);
2480         evas_map_util_3d_perspective(map, x + half_w, y + half_h, 0, FOCAL);
2481         evas_object_map_enable_set(obj, EINA_TRUE);
2482         evas_object_map_set(obj, map);
2483      }
2484    evas_map_free(map);
2485 }
2486
2487 static void *
2488 _transit_effect_rotation_context_new(float from_degree, float to_degree)
2489 {
2490    Elm_Transit_Effect_Rotation *rotation;
2491
2492    rotation = ELM_NEW(Elm_Transit_Effect_Rotation);
2493    if (!rotation) return NULL;
2494
2495    rotation->from = from_degree;
2496    rotation->to = to_degree - from_degree;
2497
2498    return rotation;
2499 }
2500
2501 /**
2502  * Add the Rotation Effect to Elm_Transit.
2503  *
2504  * @note This API is one of the facades. It creates rotation effect context
2505  * and add it's required APIs to elm_transit_effect_add.
2506  * @note This effect will be applied to the objects that are in the transit,
2507  * If you change the set of objects in the transit with  elm_transit_object_add()
2508  * or elm_transit_object_remove(), the set of objects affected by this effect
2509  * will be changed too.
2510  *
2511  * @see elm_transit_effect_add()
2512  *
2513  * @param transit Transit object.
2514  * @param from_degree Degree when effect begins.
2515  * @param to_degree Degree when effect is ends.
2516  * @return Rotation effect context data.
2517  *
2518  * @ingroup Transit
2519  * @warning Is higher recommended just create a transit with this effect when
2520  * the window that the objects of the transit belongs has already been created.
2521  * This is because this effect needs the geometry information about the objects,
2522  * and if the window was not created yet, it can get a wrong information.
2523  * @warning Is not recommended remove or add an object after the transit begins
2524  * to run, because the order of the objects will be affected.
2525  */
2526 EAPI void *
2527 elm_transit_effect_rotation_add(Elm_Transit *transit, float from_degree, float to_degree)
2528 {
2529    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
2530    void *effect_context = _transit_effect_rotation_context_new(from_degree, to_degree);
2531
2532    if (!effect_context) return NULL;
2533    elm_transit_effect_add(transit,
2534                           _transit_effect_rotation_op, effect_context,
2535                           _transit_effect_rotation_context_free);
2536    return effect_context;
2537 }
2538
2539
2540 ///////////////////////////////////////////////////////////////////////////////
2541 // ImageAnimation FX
2542 ///////////////////////////////////////////////////////////////////////////////
2543 typedef struct _Elm_Transit_Effect_Image_Animation Elm_Transit_Effect_Image_Animation;
2544
2545 struct _Elm_Transit_Effect_Image_Animation
2546 {
2547    Eina_List *images;
2548 };
2549
2550 static void
2551 _transit_effect_image_animation_context_free(void *data, Elm_Transit *transit __UNUSED__)
2552 {
2553    EINA_SAFETY_ON_NULL_RETURN(data);
2554    Elm_Transit_Effect_Image_Animation *image_animation = data;
2555    const char *image;
2556    Eina_List *elist, *elist_next;
2557
2558    EINA_LIST_FOREACH_SAFE(image_animation->images, elist, elist_next, image)
2559      {
2560         image_animation->images =
2561            eina_list_remove_list(image_animation->images, elist);
2562         eina_stringshare_del(image);
2563      }
2564
2565    free(data);
2566 }
2567
2568 static void
2569 _transit_effect_image_animation_op(void *data, Elm_Transit *transit, double progress)
2570 {
2571    EINA_SAFETY_ON_NULL_RETURN(data);
2572    EINA_SAFETY_ON_NULL_RETURN(transit);
2573    Eina_List *elist;
2574    Evas_Object *obj;
2575    const char *type;
2576    Elm_Transit_Effect_Image_Animation *image_animation = data;
2577    unsigned int count = 0;
2578    int len;
2579
2580    type = eina_stringshare_add("icon");
2581    len = eina_list_count(image_animation->images);
2582
2583    if (!len) count = floor(progress * len);
2584    else count = floor(progress * (len - 1));
2585
2586    EINA_LIST_FOREACH(transit->objs, elist, obj)
2587      {
2588         if (elm_widget_type_check(obj, type))
2589            elm_icon_file_set(obj,
2590                              eina_list_nth(image_animation->images, count), NULL);
2591      }
2592
2593    eina_stringshare_del(type);
2594 }
2595
2596 static void *
2597 _transit_effect_image_animation_context_new(Eina_List *images)
2598 {
2599    Elm_Transit_Effect_Image_Animation *image_animation;
2600    image_animation = ELM_NEW(Elm_Transit_Effect_Image_Animation);
2601
2602    if (!image_animation) return NULL;
2603    image_animation->images = images;
2604    return image_animation;
2605 }
2606
2607 /**
2608  * Add the Rotation Effect to Elm_Transit.
2609  *
2610  * @note This API is one of the facades. It creates image animation effect context
2611  * and add it's required APIs to elm_transit_effect_add.
2612  * The @p images parameter is a list images paths. This list and
2613  * its contents will be deleted at the end of the effect by
2614  * elm_transit_effect_image_animation_context_free() function.
2615  * @note This effect will be applied to the objects that are in the transit,
2616  * If you change the set of objects in the transit with  elm_transit_object_add()
2617  * or elm_transit_object_remove(), the set of objects affected by this effect
2618  * will be changed too.
2619  *
2620  * Example:
2621  * @code
2622  * char buf[PATH_MAX];
2623  * Eina_List *images = NULL;
2624  * Elm_Transit *transi = elm_transit_add();
2625  *
2626  * snprintf(buf, sizeof(buf), "%s/images/icon_11.png", PACKAGE_DATA_DIR);
2627  * images = eina_list_append(images, eina_stringshare_add(buf));
2628  *
2629  * snprintf(buf, sizeof(buf), "%s/images/logo_small.png", PACKAGE_DATA_DIR);
2630  * images = eina_list_append(images, eina_stringshare_add(buf));
2631  * elm_transit_effect_image_animation_add(transi, images);
2632  *
2633  * @endcode
2634  *
2635  * @see elm_transit_effect_add()
2636  *
2637  * @param transit Transit object.
2638  * @param images Eina_List of images file paths. This list and
2639  * its contents will be deleted at the end of the effect by
2640  * elm_transit_effect_image_animation_context_free() function.
2641  * @return Image Animation effect context data.
2642  *
2643  * @ingroup Transit
2644  */
2645 EAPI void *
2646 elm_transit_effect_image_animation_add(Elm_Transit *transit, Eina_List *images)
2647 {
2648    ELM_TRANSIT_CHECK_OR_RETURN(transit, NULL);
2649    void *effect_context = _transit_effect_image_animation_context_new(images);
2650
2651    if (!effect_context) return NULL;
2652    elm_transit_effect_add(transit,
2653                           _transit_effect_image_animation_op, effect_context,
2654                           _transit_effect_image_animation_context_free);
2655    return effect_context;
2656 }