EFL_LOOP_TIMER_EVENT_TICK -> EFL_LOOP_TIMER_EVENT_TIMER_TICK

pages/develop/guides/c/core/events.md.txt

@@ -25,7 +25,7 @@ To register a callback method to be called when an object emits a given event us
 efl_event_callback_add(object, event, callback, data);
 ```
 
-Substitute *object* for any ``Eo *`` or derived object and *event* for the identifier of the event (such as ``EFL_LOOP_EVENT_POLL_HIGH`` or ``EFL_LOOP_TIMER_EVENT_TICK``). Set *callback* to the method to be called when the event occurs and *data* to any data you want to pass to your callback (if you have no need of this use ``NULL``).
+Substitute *object* for any ``Eo *`` or derived object and *event* for the identifier of the event (such as ``EFL_LOOP_EVENT_POLL_HIGH`` or ``EFL_LOOP_TIMER_EVENT_TIMER_TICK``). Set *callback* to the method to be called when the event occurs and *data* to any data you want to pass to your callback (if you have no need of this use ``NULL``).
 
 The method signature for the callback is:
 
@@ -52,7 +52,7 @@ efl_event_callback_del(object, event, callback, data);
 The parameters here have the same meaning as for ``efl_event_callback_add()``. Note that in order to unregister the callback you have to provide **the same parameters** you used to register it. This is because you can register different callbacks to the same event or even the same callback with different *data*.
 
 > **NOTE:**
-> Registering and unregistering callbacks is an resource-intensive process. If you perform these operations continuously on several callbacks at the same time do so in a batch as this is more efficient. You can use ``efl_even_callback_array_add()`` and ``efl_even_callback_array_del()`` to accomplish this. Remember however that you can't unregister an individual callback which has been registered in a batch. They must all be unregistered together. 
+> Registering and unregistering callbacks is an resource-intensive process. If you perform these operations continuously on several callbacks at the same time do so in a batch as this is more efficient. You can use ``efl_event_callback_array_add()`` and ``efl_event_callback_array_del()`` to accomplish this. Remember however that you can't unregister an individual callback which has been registered in a batch. They must all be unregistered together. 
 
 Below is an example code snippet based on [reference/c/core/src/core_event.c](https://git.enlightenment.org/enlightenment/examples/src/branch/master/reference/c/core/src/core_event.c):
 
@@ -71,7 +71,7 @@ setup()
    efl_add(EFL_LOOP_TIMER_CLASS, mainloop,
            efl_name_set(efl_added, "timer2"),
            efl_loop_timer_interval_set(efl_added, .1),
-           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, callback, polled));
+           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, callback, mainloop));
    [...]
 }
 ```

pages/develop/guides/c/core/main-loop.md.txt

@@ -49,10 +49,10 @@ If you want to manually destroy a timer use the regular ``efl_unref()`` or ``efl
 
 ### The Timer Callback ###
 
-Register the callback using ``efl_event_callback_add()`` and the ``EFL_LOOP_TIMER_EVENT_TICK`` event as explained in the [Events Programming Guide](events.md).
+Register the callback using ``efl_event_callback_add()`` and the ``EFL_LOOP_TIMER_EVENT_TIMER_TICK`` event as explained in the [Events Programming Guide](events.md).
 
 ```c
-efl_event_callback_add(timer_object, EFL_LOOP_TIMER_EVENT_TICK, _timer_cb, NULL);
+efl_event_callback_add(timer_object, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _timer_cb, NULL);
 ```
 
 The callback has the usual event handler signature:

pages/develop/guides/c/porting-guide.md.txt

@@ -24,7 +24,7 @@ Efl_Loop *main_loop = event->object
 Programming guides: [Unified EFL](/develop/guides/c/core/main-loop.md#Timers), [Legacy EFL](/develop/legacy/program_guide/main_loop/timers)
 
 * Timers are now regular Eo objects created with ``efl_add(EFL_LOOP_TIMER_CLASS, ...)`` and destroyed with ``efl_unref()``.
-* The timer callback is registered with ``efl_event_callback_add(timer_object, EFL_LOOP_TIMER_EVENT_TICK, ...)``.
+* The timer callback is registered with ``efl_event_callback_add(timer_object, EFL_LOOP_TIMER_EVENT_TIMER_TICK, ...)``.
 * Timers are always periodic. The callback does not return ``ECORE_CALLBACK_RENEW`` or ``ECORE_CALLBACK_CANCEL`` anymore. If you want a one-shot timer, remove it from the callback after it has fired once.
 * ``ecore_timer_interval_set/get()`` -> ``efl_loop_timer_interval_set/get()``
 * ``ecore_timer_pending_get()`` -> ``efl_loop_timer_pending_get()``

pages/develop/tutorials/c/lifecycle.md.txt

@@ -109,7 +109,7 @@ Now create a timer at the end of ``efl_main()`` that will periodically call the
 ```c
    [...]
    efl_add(EFL_LOOP_TIMER_CLASS, ev->object,
-           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _lifecycle_simulation, ev->object),
+           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _lifecycle_simulation, ev->object),
            efl_loop_timer_interval_set(efl_added, 1.0));
 ```
 
@@ -184,7 +184,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
    // The timer function will trigger the chain of simulated events to show
    // how an app could respond to system lifecycle events.
    efl_add(EFL_LOOP_TIMER_CLASS, ev->object,
-           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _lifecycle_simulation, ev->object),
+           efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TIMER_TICK, _lifecycle_simulation, ev->object),
            efl_loop_timer_interval_set(efl_added, 1.0));
 }
 EFL_MAIN_EX()