static Eina_Bool
_ecore_timer_add(Ecore_Timer *obj,
Ecore_Timer_Private_Data *timer,
double now,
double in,
Ecore_Task_Cb func,
const void *data)
{
if (EINA_UNLIKELY(!eina_main_loop_is()))
{
eo_error_set(obj);
EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
}
timer->obj = obj;
eo_do_super(obj, eo_constructor());
eo_manual_free_set(obj, EINA_TRUE);
if (!func)
{
eo_error_set(obj);
ERR("callback function must be set up for an object of class: '%s'", MY_CLASS_NAME);
return EINA_FALSE;
}
if (in < 0.0) in = 0.0;
#ifdef WANT_ECORE_TIMER_DUMP
timer->timer_bt_num = backtrace((void **)(timer->timer_bt),
ECORE_TIMER_DEBUG_BT_NUM);
#endif
_ecore_timer_set(obj, now + in, in, func, (void *)data);
return EINA_TRUE;
}
static Eina_Bool
_ecore_idle_enterer_add(Ecore_Idle_Enterer *obj,
Ecore_Idle_Enterer_Data *ie,
Ecore_Task_Cb func,
const void *data)
{
if (EINA_UNLIKELY(!eina_main_loop_is()))
{
eo_error_set(obj);
EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
}
ie->obj = obj;
eo_do_super(obj, MY_CLASS, eo_constructor());
eo_manual_free_set(obj, EINA_TRUE);
if (!func)
{
eo_error_set(obj);
ERR("callback function must be set up for an object of class: '%s'", MY_CLASS_NAME);
return EINA_FALSE;
}
ie->func = func;
ie->data = (void *)data;
return EINA_TRUE;
}
/**
* Create two file descriptors (sockets on Windows). Add
* a callback that will be called when the file descriptor that
* is listened receives data. An event is also put in the event
* queue when data is received.
*
* @param handler The handler called when data is received.
* @param data Data to pass to @p handler when it is called.
* @return A newly created Ecore_Pipe object if successful.
* @c NULL otherwise.
*/
EAPI Ecore_Pipe *
ecore_pipe_add(Ecore_Pipe_Cb handler,
const void *data)
{
Ecore_Pipe *p;
int fds[2];
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
if (!handler) return NULL;
p = ecore_pipe_calloc(1);
if (!p) return NULL;
if (pipe(fds))
{
ecore_pipe_mp_free(p);
return NULL;
}
ECORE_MAGIC_SET(p, ECORE_MAGIC_PIPE);
p->fd_read = fds[0];
p->fd_write = fds[1];
p->handler = handler;
p->data = data;
fcntl(p->fd_read, F_SETFL, O_NONBLOCK);
p->fd_handler = ecore_main_fd_handler_add(p->fd_read,
ECORE_FD_READ,
_ecore_pipe_read,
p,
NULL, NULL);
return p;
}
EAPI Ecore_Exe *
ecore_exe_run(const char *exe_cmd,
const void *data)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
return ecore_exe_pipe_run(exe_cmd, 0, data);
}
EAPI void *
ecore_animator_del(Ecore_Animator *animator)
{
void *data = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
if (!ECORE_MAGIC_CHECK(animator, ECORE_MAGIC_ANIMATOR))
{
ECORE_MAGIC_FAIL(animator, ECORE_MAGIC_ANIMATOR,
"ecore_animator_del");
goto unlock;
}
if (animator->delete_me)
{
data = animator->data;
goto unlock;
}
animator->delete_me = EINA_TRUE;
animators_delete_me++;
if (animator->run_func)
data = animator->run_data;
else
data = animator->data;
unlock:
_ecore_unlock();
return data;
}
/**
* Free an Ecore_Pipe object created with ecore_pipe_add().
*
* @param p The Ecore_Pipe object to be freed.
* @return The pointer to the private data
*/
EAPI void *
ecore_pipe_del(Ecore_Pipe *p)
{
void *r;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
r = _ecore_pipe_del(p);
_ecore_unlock();
return r;
}
/**
* Creates a timer to call the given function in the given period of time.
* @param in The interval in seconds.
* @param func The given function. If @p func returns 1, the timer is
* rescheduled for the next interval @p in.
* @param data Data to pass to @p func when it is called.
* @return A timer object on success. @c NULL on failure.
*
* This function adds a timer and returns its handle on success and NULL on
* failure. The function @p func will be called every @p in seconds. The
* function will be passed the @p data pointer as its parameter.
*
* When the timer @p func is called, it must return a value of either 1
* (or ECORE_CALLBACK_RENEW) or 0 (or ECORE_CALLBACK_CANCEL).
* 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_Timer *
ecore_timer_add(double in,
Ecore_Task_Cb func,
const void *data)
{
Ecore_Timer *timer = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
timer = eo_add_custom(MY_CLASS, _ecore_parent, ecore_timer_constructor(in, func, data));
eo_unref(timer);
return timer;
}
EAPI Ecore_Animator *
ecore_animator_add(Ecore_Task_Cb func,
const void *data)
{
Ecore_Animator *animator;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
animator = _ecore_animator_add(func, data);
_ecore_unlock();
return animator;
}
EAPI void *
ecore_idler_del(Ecore_Idler *idler)
{
void *data = NULL;
if (!idler) return NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
data = _ecore_idler_del(idler);
_ecore_unlock();
return data;
}
/**
* Delete an idle exiter handler from the list to be run on exiting idle state.
* @param idle_exiter The idle exiter to delete
* @return The data pointer that was being being passed to the handler if
* successful. NULL otherwise.
*/
EAPI void *
ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
{
void *data;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
if (!ECORE_MAGIC_CHECK(idle_exiter, ECORE_MAGIC_IDLE_EXITER))
{
ECORE_MAGIC_FAIL(idle_exiter, ECORE_MAGIC_IDLE_EXITER,
"ecore_idle_exiter_del");
return NULL;
}
_ecore_lock();
data = _ecore_idle_exiter_del(idle_exiter);
_ecore_unlock();
return data;
}
/**
* Add an idle exiter handler.
* @param func The function to call when exiting an idle state.
* @param data The data to be passed to the @p func call
* @return A handle to the idle exiter callback on success. NULL otherwise.
* @note The function func will be called every time the main loop is exiting
* idle state, as long as it returns 1 (or ECORE_CALLBACK_RENEW). A return of 0
* (or ECORE_CALLBACK_CANCEL) deletes the idle exiter.
*/
EAPI Ecore_Idle_Exiter *
ecore_idle_exiter_add(Ecore_Task_Cb func,
const void *data)
{
Ecore_Idle_Exiter *ie = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
if (!func) goto unlock;
ie = ecore_idle_exiter_calloc(1);
if (!ie) goto unlock;
ECORE_MAGIC_SET(ie, ECORE_MAGIC_IDLE_EXITER);
ie->func = func;
ie->data = (void *)data;
idle_exiters = (Ecore_Idle_Exiter *)eina_inlist_append(EINA_INLIST_GET(idle_exiters), EINA_INLIST_GET(ie));
unlock:
_ecore_unlock();
return ie;
}
EAPI Ecore_Animator *
ecore_animator_timeline_add(double runtime,
Ecore_Timeline_Cb func,
const void *data)
{
Ecore_Animator *animator;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
_ecore_lock();
if (runtime <= 0.0) runtime = 0.0;
animator = _ecore_animator_add(_ecore_animator_run, NULL);
animator->data = animator;
animator->run_func = func;
animator->run_data = (void *)data;
animator->start = ecore_loop_time_get();
animator->run = runtime;
_ecore_unlock();
return animator;
}
/**
* Free an Ecore_Pipe object created with ecore_pipe_add().
*
* @param p The Ecore_Pipe object to be freed.
* @return The pointer to the private data
*/
EAPI void *
ecore_pipe_del(Ecore_Pipe *p)
{
void *data;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
{
ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_del");
return NULL;
}
p->delete_me = EINA_TRUE;
if (p->handling > 0) return (void *)p->data;
if (p->fd_handler) _ecore_main_fd_handler_del(p->fd_handler);
if (p->fd_read != PIPE_FD_INVALID) pipe_close(p->fd_read);
if (p->fd_write != PIPE_FD_INVALID) pipe_close(p->fd_write);
data = (void *)p->data;
ecore_pipe_mp_free(p);
return data;
}
/**
* Retrieves the current precision used by timer infrastructure.
* @return Current precision.
* @see ecore_timer_precision_set()
*/
EAPI double
ecore_timer_precision_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
return precision;
}
/**
* @brief Wait from another thread on the read side of a pipe.
*
* @param p The pipe to watch on.
* @param message_count The minimal number of message to wait before exiting.
* @param wait The amount of time in second to wait before exiting.
* @return the number of message catched during that wait call.
* @since 1.1
*
* Negative value for @p wait means infite wait.
*/
EAPI int
ecore_pipe_wait(Ecore_Pipe *p,
int message_count,
double wait)
{
struct timeval tv, *t;
fd_set rset;
double end = 0.0;
double timeout;
int ret;
int total = 0;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(-1);
if (p->fd_read == PIPE_FD_INVALID)
return -1;
FD_ZERO(&rset);
FD_SET(p->fd_read, &rset);
if (wait >= 0.0)
end = ecore_loop_time_get() + wait;
timeout = wait;
while (message_count > 0 && (timeout > 0.0 || wait <= 0.0))
{
if (wait >= 0.0)
{
/* finite() tests for NaN, too big, too small, and infinity. */
if ((!ECORE_FINITE(timeout)) || (timeout == 0.0))
{
tv.tv_sec = 0;
tv.tv_usec = 0;
}
else if (timeout > 0.0)
{
int sec, usec;
#ifdef FIX_HZ
timeout += (0.5 / HZ);
sec = (int)timeout;
usec = (int)((timeout - (double)sec) * 1000000);
#else
sec = (int)timeout;
usec = (int)((timeout - (double)sec) * 1000000);
#endif
tv.tv_sec = sec;
tv.tv_usec = usec;
}
t = &tv;
}
else
{
t = NULL;
}
ret = main_loop_select(p->fd_read + 1, &rset, NULL, NULL, t);
if (ret > 0)
{
_ecore_pipe_read(p, NULL);
message_count -= p->message;
total += p->message;
p->message = 0;
}
else if (ret == 0)
{
break;
}
else if (errno != EINTR)
{
close(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
break;
}
if (wait >= 0.0)
timeout = end - ecore_loop_time_get();
}
return total;
}
EAPI Ecore_Animator_Source
ecore_animator_source_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return src;
}
EAPI double
ecore_animator_frametime_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
return animators_frametime;
}
EAPI int
ecore_exe_run_priority_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return _impl_ecore_exe_run_priority_get();
}
