You can change an object on the screen at certain intervals using an
animation. To create an animation, you must first determine the duration
of the animation, and then define a callback function that performs the
actual animation with that duration.

In the following example, 2 square rectangles are animated. One of them
simply moves on the screen, while the other also changes its color and
size while moving.

The following example uses the same Basic UI template as the square
drawing example. For more information on how to create the project with
the template, see Squares on the Canvas.

To implement animations in an application:

  1. Create a new project and specify the project name as AnimatorEx.

  2. After the project is created, open the .c source file in the src
    folder and add the new code to the create_base_gui() function to
    create 2 rectangles and 2 animations.

    The following functions are used to create the animations:

    • ecore_animator_frametime_set() specifies a frame time interval
      for an animation. For example, if you specify the interval as
      1/50, 50 frame events occur in 1 second. The unit is seconds.

    • ecore_animator_timeline_add() creates an Animator object
      with a limited time specified in seconds by the first parameter.
      Once the runtime of the animator has elapsed, it is
      deleted automatically.

      The second parameter indicates the frame event callback function
      that actually defines the animation details, and the third
      parameter indicates the user data, which generally passes an
      object or application data to which you apply the animation.

      The callback function can return ECORE_CALLBACK_RENEW to keep
      the animator running or ECORE_CALLBACK_CANCEL to stop it and
      automatically delete it at any time.

    • ecore_animator_add() creates an Animator object. The first
      parameter indicates the frame event callback function that
      actually defines the animation details, and the second parameter
      indicates the user data.

      The ecore_animator_timeline_add() function is exactly like the
      ecore_animator_add() function, except that the animator only
      runs for a limited time.

    • ecore_timer_add() creates a timer to call the given function
      in the given period of time. The first parameter is the interval
      in seconds, and the second parameter is the given function.

      If this function returns ECORE_CALLBACK_RENEW, the timer is
      rescheduled for the next interval given in the first parameter.
      If it returns ECORE_CALLBACK_CANCEL, the timer is
      deleted automatically. The third parameter indicates the user
      data to pass to the function when it is called.

    The label is not used in this example, so annotate it.

       Create and initialize elm_conformant
       elm_conformant is mandatory for the base GUI to have a proper size
       when the indicator or virtual keypad is visible
    ad->conform = elm_conformant_add(ad->win);
    elm_win_indicator_mode_set(ad->win, ELM_WIN_INDICATOR_SHOW);
    elm_win_indicator_opacity_set(ad->win, ELM_WIN_INDICATOR_OPAQUE);
    evas_object_size_hint_weight_set(ad->conform, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
    elm_win_resize_object_add(ad->win, ad->conform);
       Create an actual view of the base GUI
       Modify this part to change the view
    #if 0 /* _NOT_USED */
        ad->label = elm_label_add(ad->conform);
        elm_object_text_set(ad->label, "<align=center>Hello Tizen</align>");
        evas_object_size_hint_weight_set(ad->label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
        elm_object_content_set(ad->conform, ad->label);
    /* Evas */
    Evas *evas = evas_object_evas_get(ad->conform);
    /* Rect */
    Evas_Object * rect = evas_object_rectangle_add(evas);
    evas_object_color_set(rect, 0, 0, 255, 255);
    evas_object_resize(rect, 50, 50);
    Evas_Object *rect2 = evas_object_rectangle_add(evas);
    evas_object_color_set(rect2, 0, 55, 0, 255);
    evas_object_resize(rect2, 50, 50);
    /* Animation */
    ecore_animator_frametime_set(1. / 50);
    Ecore_Animator *anim = ecore_animator_timeline_add(5, _advance_frame, rect);
    Ecore_Animator *anim2 = ecore_animator_add(_advance_frame3, rect2);
    Ecore_Timer *timer1 = ecore_timer_add(10, _start_second_anim, rect);
    Ecore_Timer *timer2 = ecore_timer_add(5, _freeze_third_anim, rect2);
    Ecore_Timer *timer3 = ecore_timer_add(10, _thaw_third_anim, rect2);
    /* Show the window after the base GUI is set up */
  3. Create the frame event callback functions by adding them to the top
    of the create_base_gui() function:

    • The code of the _advance_frame() timeline animation frame
      event callback function specifies the new size, position, and
      color of the square. It changes the blue square to red and grows
      it larger as it moves toward the bottom right. The style applied
      to the animation is ECORE_POS_MAP_LINEAR, which keeps the
      animation moving at a certain speed.
    • The code of the _advance_frame2() timeline animation frame
      event callback function also specifies the size, position, and
      color of a square. The style applied to the animation is
      ECORE_POS_MAP_BOUNCE, which creates a vibration like a
      bouncing ball. It slows to a stop after bouncing off the
      ending point.
    • The code of the _advance_frame3() timeline animation frame
      event callback function increases the X coordinate of an object
      by 2 at every frame. The static variable x is used in order to
      increase the X coordinate whenever this function is called. When
      the X coordinate becomes greater than 250, it starts back
      from 0. The evas_object_move() function changes the position
      of an object.

    The ecore_animator_pos_map() function returns the resulting value
    that is mapped onto the position of the current animation. The
    returned values range between 0 and 1. The resulting value when the
    animation starts is 0, and it gradually increases and eventually
    reaches 1 when the animation stops.

    The second parameter of the timeline animation event function must
    be passed to the first parameter of the
    ecore_animator_pos_map() function. For the second parameter, enter
    the style of the animation. The style types are described in the
    _Ecore_Pos_Map enumeration (in
    wearable applications)
    that defines the position mappings for the animation. For the third
    and fourth parameter, enter the intensity and tempo of the
    speed change.

    The _advance_frame() function is only valid for 5 seconds, since
    its runtime (specified by the first parameter of the
    ecore_animator_timeline_add() function) is 5 seconds. Therefore,
    the _advance_frame() function is automatically deleted after
    5 seconds. The freeze_third_anim() function is called 5 seconds
    after the application starts, and the ecore_animator_freeze()
    function pauses the animation. The thaw_third_anim() and
    _start_second_anim() functions are called 10 seconds after the
    application starts, and the ecore_animator_thaw() function
    restarts the animation.

    static Eina_Bool
    _advance_frame(void *data, double pos)
        double frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_LINEAR, 12, 15);
        evas_object_resize(data, 50 * (1 + frame), 50 * (1 + frame));
        evas_object_move(data, 100 * frame, 100 * frame);
        evas_object_color_set(data, 255 * frame, 0, 255 * (1 - frame), 255);
        return ECORE_CALLBACK_RENEW;
    static Eina_Bool
    _advance_frame2(void *data, double pos)
        double frame = ecore_animator_pos_map(pos, ECORE_POS_MAP_BOUNCE, 1.2, 50);
        evas_object_resize(data, 100 - (50 * frame), 100 - (50 * frame));
        evas_object_move(data, 100 * (1 - frame), 100 * (1 - frame));
        evas_object_color_set(data, 255 * (1 - frame), 0, 255 * frame, 255);
        return ECORE_CALLBACK_RENEW;
    static Eina_Bool
    _advance_frame3(void * data)
        static int x = 0;
        if (x >= 250)
            x = 0;
        evas_object_move(data, x += 2, 350);
        return ECORE_CALLBACK_RENEW;
    static Eina_Bool
    _start_second_anim(void *data)
        ecore_animator_timeline_add(20, _advance_frame2, data);
    static Eina_Bool
    _freeze_third_anim(void *data)
        dlog_print(DLOG_ERROR, LOG_TAG, "ANIMATOR = %p", data);
    static Eina_Bool
    _thaw_third_anim(void *data)
  4. Build and run the application.

    2 squares are shown on the screen:

    • The green square moves from left to right. When the green square
      has moved a certain distance, it restarts its movement from the
      left end of the screen.

    • The blue square turns red and becomes larger as it moves to the
      bottom right for 5 seconds. From 5 to 10 seconds, 2 squares
      are paused. After 10 seconds, they are resumed, and the red
      square turns blue and becomes smaller as it moves to the top
      left for 20 seconds.

      Create the project