/usr/include/ecore-1/Ecore_Legacy.h is in libecore-dev 1.8.6-2.5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 | #ifdef __cplusplus
extern "C" {
#endif
/**
* @ingroup Ecore_Poller_Group
*
* @{
*/
/**
* @brief Changes the polling interval rate of @p poller.
* @param poller The Ecore_Poller to change the interval of.
* @param interval The tick interval to set; must be a power of 2 and <= 32768.
* @return Returns true on success, false on failure.
*
* This allows the changing of a poller's polling interval. It is useful when
* you want to alter a poll rate without deleting and re-creating a poller.
*/
EAPI Eina_Bool ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval);
/**
* @brief Gets the polling interval rate of @p poller.
* @param poller The Ecore_Poller to change the interval of.
* @return Returns the interval, in ticks, that @p poller polls at.
*
* This returns a poller's polling interval, or 0 on error.
*/
EAPI int ecore_poller_poller_interval_get(Ecore_Poller *poller);
/**
* @brief Creates a poller to call the given function at a particular tick interval.
* @param type The ticker type to attach the poller to. Must be ECORE_POLLER_CORE.
* @param interval The poll interval.
* @param func The poller function.
* @param data Data to pass to @a func when it is called.
* @return A poller object on success, @c NULL otherwise.
*
* This function adds @a func as a poller callback that will be called every @a
* interval ticks together with other pollers of type @a type. @a func will be
* passed the @p data pointer as a parameter.
*
* The @p interval must be between 1 and 32768 inclusive, and must be a power of
* 2 (i.e. 1, 2, 4, 8, 16, ... 16384, 32768). The exact tick in which @a func
* will be called is undefined, as only the interval between calls can be
* defined. Ecore will endeavor to keep pollers synchronized and to call as
* many in 1 wakeup event as possible. If @a interval is not a power of two, the
* closest power of 2 greater than @a interval will be used.
*
* When the poller @p func is called, it must return a value of either
* ECORE_CALLBACK_RENEW(or 1) or ECORE_CALLBACK_CANCEL(or 0). If it
* returns 1, it will be called again at the next tick, or if it returns
* 0 it will be deleted automatically making any references/handles for it
* invalid.
*/
EAPI Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_Task_Cb func, const void *data);
/**
* @brief Delete the specified poller from the timer list.
* @param poller The poller to delete.
* @return The data pointer set for the timer when @ref ecore_poller_add was
* called on success, @c NULL otherwise.
*
* @note @a poller must be a valid handle. If the poller function has already
* returned 0, the handle is no longer valid (and does not need to be deleted).
*/
EAPI void *ecore_poller_del(Ecore_Poller *poller);
/**
* @}
*/
/**
* @ingroup Ecore_Animator_Group
*
* @{
*/
/**
* @brief Add an animator to call @p func at every animation tick during main
* loop execution.
*
* @param func The function to call when it ticks off
* @param data The data to pass to the function
* @return A handle to the new animator
*
* This function adds an animator and returns its handle on success and @c NULL
* on failure. The function @p func will be called every N seconds where N is
* the @p frametime interval set by ecore_animator_frametime_set(). The
* function will be passed the @p data pointer as its parameter.
*
* When the animator @p func is called, it must return a boolean value.
* If it returns EINA_TRUE (or ECORE_CALLBACK_RENEW), it will be called again at
* the next tick, or if it returns EINA_FALSE (or ECORE_CALLBACK_CANCEL) it will be
* deleted automatically making any references/handles for it invalid.
*
* @note The default @p frametime value is 1/30th of a second.
*
* @see ecore_animator_timeline_add()
* @see ecore_animator_frametime_set()
*/
EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
/**
* @brief Add an animator that runs for a limited time
*
* @param runtime The time to run in seconds
* @param func The function to call when it ticks off
* @param data The data to pass to the function
* @return A handle to the new animator
*
* This function is just like ecore_animator_add() except the animator only
* runs for a limited time specified in seconds by @p runtime. Once the
* runtime the animator has elapsed (animator finished) it will automatically
* be deleted. The callback function @p func can return ECORE_CALLBACK_RENEW
* to keep the animator running or ECORE_CALLBACK_CANCEL ro stop it and have
* it be deleted automatically at any time.
*
* The @p func will ALSO be passed a position parameter that will be in value
* from 0.0 to 1.0 to indicate where along the timeline (0.0 start, 1.0 end)
* the animator run is at. If the callback wishes not to have a linear
* transition it can "map" this value to one of several curves and mappings
* via ecore_animator_pos_map().
*
* @note The default @p frametime value is 1/30th of a second.
*
* @see ecore_animator_add()
* @see ecore_animator_pos_map()
* @since 1.1.0
*/
EAPI Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_Cb func, const void *data);
/**
* @brief Delete the specified animator from the animator list.
*
* @param animator The animator to delete
* @return The data pointer set for the animator on add
*
* Delete the specified @p animator from the set of animators that are
* executed during main loop execution. This function returns the data
* parameter that was being passed to the callback on success, or @c NULL on
* failure. After this call returns the specified animator object @p animator
* is invalid and should not be used again. It will not get called again after
* deletion.
*/
EAPI void *ecore_animator_del(Ecore_Animator *animator);
/**
* @brief Suspend the specified animator.
*
* @param animator The animator to delete
*
* The specified @p animator will be temporarily removed from the set of
* animators that are executed during main loop.
*
* @warning Freezing an animator doesn't freeze accounting of how long that
* animator has been running. Therefore if the animator was created with
*ecore_animator_timeline_add() the @p pos argument given to the callback
* will increase as if the animator hadn't been frozen and the animator may
* have it's execution halted if @p runtime elapsed.
*/
EAPI void ecore_animator_freeze(Ecore_Animator *animator);
/**
* @brief Restore execution of the specified animator.
*
* @param animator The animator to delete
*
* The specified @p animator will be put back in the set of animators that are
* executed during main loop.
*/
EAPI void ecore_animator_thaw(Ecore_Animator *animator);
/**
* @}
*/
/**
* @ingroup Ecore_Timer_Group
*
* @{
*/
EAPI Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *data);
EAPI Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data);
EAPI void *ecore_timer_del(Ecore_Timer *timer);
EAPI void ecore_timer_interval_set(Ecore_Timer *timer, double in);
EAPI double ecore_timer_interval_get(Ecore_Timer *timer);
EAPI void ecore_timer_freeze(Ecore_Timer *timer);
EAPI void ecore_timer_thaw(Ecore_Timer *timer);
EAPI void ecore_timer_delay(Ecore_Timer *timer, double add);
EAPI void ecore_timer_reset(Ecore_Timer *timer);
EAPI double ecore_timer_pending_get(Ecore_Timer *timer);
/**
* @}
*/
/**
* @ingroup Ecore_Idle_Group
*
* @{
*/
/**
* Add an idler handler.
* @param func The function to call when idling.
* @param data The data to be passed to this @p func call.
* @return A idler handle if successfully added, @c NULL otherwise.
*
* Add an idler handle to the event loop, returning a handle on
* success and @c NULL otherwise. The function @p func will be called
* repeatedly while no other events are ready to be processed, as
* long as it returns @c 1 (or ECORE_CALLBACK_RENEW). A return of @c 0
* (or ECORE_CALLBACK_CANCEL) deletes the idler.
*
* Idlers are useful for progressively prossessing data without blocking.
*/
EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
/**
* Delete an idler callback from the list to be executed.
* @param idler The handle of the idler callback to delete
* @return The data pointer passed to the idler callback on success, @c NULL
* otherwise.
*/
EAPI void *ecore_idler_del(Ecore_Idler *idler);
EAPI Ecore_Idle_Enterer *ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data);
EAPI Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data);
EAPI void *ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
EAPI Ecore_Idle_Exiter *ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data);
EAPI void *ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
/**
* @}
*/
/**
* @ingroup Ecore_Job_Group
*
* @{
*/
EAPI Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
EAPI void *ecore_job_del(Ecore_Job *obj);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
|