forked from enlightenment/efl
parent
58f5409b49
commit
a17c58d0b0
|
@ -54,7 +54,7 @@ These routines are used for Ecore Library interaction
|
|||
Ecore is a library of convenience functions.
|
||||
|
||||
The Ecore library provides the following modules:
|
||||
@li @link Ecore.h Ecore - Main Loop and Job Functions. @endlink
|
||||
@li @ref Ecore_Group
|
||||
@li @ref Ecore_Con_Group
|
||||
@li @link Ecore_Evas.h Ecore_Evas - Evas convenience functions. @endlink
|
||||
@li @ref Ecore_FB_Group
|
||||
|
@ -245,63 +245,6 @@ This page briefly explains what the X window system is and various terms
|
|||
that are used.
|
||||
*/
|
||||
|
||||
// GROUP DEFINITIONS
|
||||
|
||||
/**
|
||||
@defgroup Ecore_Timer_Group Ecore Timer
|
||||
|
||||
The timer allows callbacks to be called at specific intervals.
|
||||
*/
|
||||
|
||||
/**
|
||||
@defgroup Ecore_Job_Group Ecore Jobs
|
||||
|
||||
You can queue jobs that are to be done by the main loop when the current
|
||||
event is dealt with.
|
||||
*/
|
||||
|
||||
/**
|
||||
@defgroup Idle_Group Idle Handlers
|
||||
|
||||
Callbacks that are called when the program enters or exits an idle state.
|
||||
|
||||
The ecore main loop enters an idle state when it is waiting for timers
|
||||
to time out, data to come in on a file descriptor or any other event
|
||||
to occur. You can set callbacks to be called when the main loop
|
||||
enters an idle state, during an idle state or just after the program
|
||||
wakes up.
|
||||
|
||||
Enterer callbacks are good for updating your program's state, if it
|
||||
has a state engine. Once all of the enterer handlers are called, the
|
||||
program will enter a "sleeping" state.
|
||||
|
||||
Idler callbacks are called when the main loop has called all enterer
|
||||
handlers. They are useful for interfaces that require polling and
|
||||
timers would be too slow to use.
|
||||
|
||||
If no idler callbacks are specified, then the process literally goes
|
||||
to sleep. Otherwise, the idler callbacks are called continuously
|
||||
while the loop is "idle", using as much CPU as is available to the
|
||||
process.
|
||||
|
||||
Exiter callbacks are called when the main loop wakes up from an idle
|
||||
state.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
@defgroup Ecore_Config_Create_Group Ecore Config Create Functions
|
||||
|
||||
Convenience functions that set default values, bounds, option values and
|
||||
descriptions in one call.
|
||||
*/
|
||||
|
||||
/**
|
||||
@defgroup Ecore_Config_File_Group Ecore Config File Functions
|
||||
|
||||
Functions that are used to load and save properties from and to files.
|
||||
*/
|
||||
|
||||
// EXAMPLES
|
||||
|
||||
/**
|
||||
|
|
|
@ -33,28 +33,6 @@
|
|||
# endif
|
||||
#endif /* ! _WIN32 */
|
||||
|
||||
/**
|
||||
* @file Ecore.h
|
||||
* @brief The file that provides the program utility, main loop and timer
|
||||
* functions.
|
||||
*
|
||||
* This header provides the Ecore event handling loop. For more
|
||||
* details, see @ref Ecore_Main_Loop_Group.
|
||||
*
|
||||
* For the main loop to be of any use, you need to be able to add events
|
||||
* and event handlers. Events for file descriptor events are covered in
|
||||
* @ref Ecore_FD_Handler_Group.
|
||||
*
|
||||
* Time functions are covered in @ref Ecore_Time_Group.
|
||||
*
|
||||
* There is also provision for callbacks for when the loop enters or
|
||||
* exits an idle state. See @ref Idle_Group for more information.
|
||||
*
|
||||
* Functions are also provided for spawning child processes using fork.
|
||||
* See @ref Ecore_Exe_Basic_Group and @ref Ecore_Exe_Signal_Group for
|
||||
* more details.
|
||||
*/
|
||||
|
||||
#ifdef _WIN32
|
||||
# include <winsock2.h>
|
||||
#elif (defined (__FreeBSD__) && (__FreeBSD_version >= 420001)) || defined (__OpenBSD__)
|
||||
|
@ -71,6 +49,29 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
* @brief The file that provides the program utility, main loop and timer
|
||||
* functions.
|
||||
*
|
||||
* This header provides the Ecore event handling loop. For more
|
||||
* details, see @ref Ecore_Main_Loop_Group.
|
||||
*
|
||||
* For the main loop to be of any use, you need to be able to add events
|
||||
* and event handlers. Events for file descriptor events are covered in
|
||||
* @ref Ecore_FD_Handler_Group.
|
||||
*
|
||||
* Time functions are covered in @ref Ecore_Time_Group.
|
||||
*
|
||||
* There is also provision for callbacks for when the loop enters or
|
||||
* exits an idle state. See @ref Idle_Group for more information.
|
||||
*
|
||||
* Functions are also provided for spawning child processes using fork.
|
||||
* See @ref Ecore_Exe_Group for more details.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define ECORE_VERSION_MAJOR 1
|
||||
#define ECORE_VERSION_MINOR 0
|
||||
|
||||
|
@ -210,7 +211,7 @@ extern "C" {
|
|||
typedef void (*Ecore_Thread_Heavy_Cb) (Ecore_Thread *thread, void *data);
|
||||
/**
|
||||
* @typedef Ecore_Thread_Notify_Cb Ecore_Thread_Notify_Cb
|
||||
* A callback used by the main loop to receive data sent by an @ref Ecore_Thread.
|
||||
* A callback used by the main loop to receive data sent by an @ref Ecore_Thread_Group.
|
||||
*/
|
||||
typedef void (*Ecore_Thread_Notify_Cb) (Ecore_Thread *thread, void *msg_data, void *data);
|
||||
/**
|
||||
|
@ -325,13 +326,37 @@ extern "C" {
|
|||
Ecore_Exe_Event_Data_Line *lines; /**< an array of line data if line buffered, the last one has it's line member set to NULL */
|
||||
};
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Init_Group Ecore initialisation and shutdown functions.
|
||||
*/
|
||||
|
||||
EAPI int ecore_init(void);
|
||||
EAPI int ecore_shutdown(void);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Application_Group Ecore Application functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI void ecore_app_args_set(int argc, const char **argv);
|
||||
EAPI void ecore_app_args_get(int *argc, char ***argv);
|
||||
EAPI void ecore_app_restart(void);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Event_Group Ecore Event functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Event_Handler *ecore_event_handler_add(int type, Ecore_Event_Handler_Cb func, const void *data);
|
||||
EAPI void *ecore_event_handler_del(Ecore_Event_Handler *event_handler);
|
||||
EAPI Ecore_Event *ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data);
|
||||
|
@ -342,6 +367,15 @@ extern "C" {
|
|||
EAPI int ecore_event_current_type_get(void);
|
||||
EAPI void *ecore_event_current_event_get(void);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Exe_Group Process Spawning Functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI void ecore_exe_run_priority_set(int pri);
|
||||
EAPI int ecore_exe_run_priority_get(void);
|
||||
|
@ -369,6 +403,16 @@ extern "C" {
|
|||
EAPI void ecore_exe_signal(Ecore_Exe *exe, int num);
|
||||
EAPI void ecore_exe_hup(Ecore_Exe *exe);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Idle_Group Ecore Idle functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
|
||||
EAPI void *ecore_idler_del(Ecore_Idler *idler);
|
||||
|
||||
|
@ -379,6 +423,16 @@ extern "C" {
|
|||
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);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Main Loop_Group Ecore Main Loop functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI void ecore_main_loop_iterate(void);
|
||||
|
||||
EAPI void ecore_main_loop_select_func_set(Ecore_Select_Function func);
|
||||
|
@ -400,13 +454,31 @@ extern "C" {
|
|||
EAPI Ecore_Win32_Handler *ecore_main_win32_handler_add(void *h, Ecore_Fd_Win32_Cb func, const void *data);
|
||||
EAPI void *ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Pipe_Group Pipe wrapper
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Pipe *ecore_pipe_add(Ecore_Pipe_Cb handler, const void *data);
|
||||
EAPI void *ecore_pipe_del(Ecore_Pipe *p);
|
||||
EAPI Eina_Bool ecore_pipe_write(Ecore_Pipe *p, const void *buffer, unsigned int nbytes);
|
||||
EAPI void ecore_pipe_write_close(Ecore_Pipe *p);
|
||||
EAPI void ecore_pipe_read_close(Ecore_Pipe *p);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Thread_Group Ecore Thread functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Heavy_Cb func_blocking,
|
||||
Ecore_Cb func_end,
|
||||
|
@ -429,20 +501,26 @@ extern "C" {
|
|||
EAPI void ecore_thread_max_set(int num);
|
||||
EAPI void ecore_thread_max_reset(void);
|
||||
EAPI int ecore_thread_available_get(void);
|
||||
|
||||
EAPI Eina_Bool ecore_thread_local_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
|
||||
EAPI void *ecore_thread_local_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
|
||||
EAPI void *ecore_thread_local_data_find(Ecore_Thread *thread, const char *key);
|
||||
EAPI void *ecore_thread_local_data_find(Ecore_Thread *thread, const char *key);
|
||||
EAPI Eina_Bool ecore_thread_local_data_del(Ecore_Thread *thread, const char *key);
|
||||
|
||||
EAPI Eina_Bool ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
|
||||
EAPI void *ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb);
|
||||
EAPI void *ecore_thread_global_data_find(const char *key);
|
||||
EAPI void *ecore_thread_global_data_find(const char *key);
|
||||
EAPI Eina_Bool ecore_thread_global_data_del(const char *key);
|
||||
EAPI void *ecore_thread_global_data_wait(const char *key, double seconds);
|
||||
|
||||
EAPI void *ecore_thread_global_data_wait(const char *key, double seconds);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Time_Group Ecore Time functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI double ecore_time_get(void);
|
||||
EAPI double ecore_time_unix_get(void);
|
||||
|
@ -457,10 +535,19 @@ extern "C" {
|
|||
EAPI void ecore_timer_thaw(Ecore_Timer *timer);
|
||||
EAPI void ecore_timer_delay(Ecore_Timer *timer, double add);
|
||||
EAPI double ecore_timer_pending_get(Ecore_Timer *timer);
|
||||
|
||||
EAPI double ecore_timer_precision_get(void);
|
||||
EAPI void ecore_timer_precision_set(double precision);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Animator_Group Ecore Animator functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
|
||||
EAPI void *ecore_animator_del(Ecore_Animator *animator);
|
||||
EAPI void ecore_animator_freeze(Ecore_Animator *animator);
|
||||
|
@ -468,6 +555,16 @@ extern "C" {
|
|||
EAPI void ecore_animator_frametime_set(double frametime);
|
||||
EAPI double ecore_animator_frametime_get(void);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Poller_Group Ecore Poll functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI void ecore_poller_poll_interval_set(Ecore_Poller_Type type, double poll_time);
|
||||
EAPI double ecore_poller_poll_interval_get(Ecore_Poller_Type type);
|
||||
EAPI Eina_Bool ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval);
|
||||
|
@ -475,9 +572,27 @@ extern "C" {
|
|||
EAPI Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_Task_Cb func, const void *data);
|
||||
EAPI void *ecore_poller_del(Ecore_Poller *poller);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Job_Group Ecore Job functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
EAPI Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
|
||||
EAPI void *ecore_job_del(Ecore_Job *job);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -61,6 +61,12 @@ int _ecore_fps_debug = 0;
|
|||
# define CODESET "INVALID"
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Init_Group Ecore initialisation and shutdown functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Set up connections, signal handlers, sockets etc.
|
||||
* @return 1 or greater on success, 0 otherwise
|
||||
|
@ -197,6 +203,10 @@ ecore_shutdown(void)
|
|||
return _ecore_init_count;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
EAPI void
|
||||
ecore_print_warning(const char *function, const char *sparam)
|
||||
{
|
||||
|
@ -416,4 +426,5 @@ _ecore_memory_statistic(__UNUSED__ void *data)
|
|||
|
||||
return ECORE_CALLBACK_RENEW;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
@ -29,12 +29,23 @@ static int animators_delete_me = 0;
|
|||
static Ecore_Animator *animators = NULL;
|
||||
static double animators_frametime = 1.0 / 30.0;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Animator_Group Ecore Animator functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Add a animator to tick off at every animaton 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
|
||||
* @ingroup Ecore_Animator_Group
|
||||
*
|
||||
* This function adds a animator and returns its handle on success and NULL on
|
||||
* failure. The function @p func will be called every N seconds where N is the
|
||||
|
@ -74,7 +85,6 @@ ecore_animator_add(Ecore_Task_Cb func, const void *data)
|
|||
* Delete the specified animator from the animator list.
|
||||
* @param animator The animator to delete
|
||||
* @return The data pointer set for the animator
|
||||
* @ingroup Ecore_Animator_Group
|
||||
*
|
||||
* Delete the specified @p aqnimator from the set of animators that are executed
|
||||
* during main loop execution. This function returns the data parameter that
|
||||
|
@ -133,7 +143,6 @@ ecore_animator_frametime_get(void)
|
|||
/**
|
||||
* Suspend the specified animator.
|
||||
* @param animator The animator to delete
|
||||
* @ingroup Ecore_Animator_Group
|
||||
*
|
||||
* The specified @p animator will be temporarly removed from the set of animators
|
||||
* that are executed during main loop execution.
|
||||
|
@ -154,7 +163,6 @@ ecore_animator_freeze(Ecore_Animator *animator)
|
|||
/**
|
||||
* Restore execution of the specified animator.
|
||||
* @param animator The animator to delete
|
||||
* @ingroup Ecore_Animator_Group
|
||||
*
|
||||
* The specified @p animator will be put back in the set of animators
|
||||
* that are executed during main loop execution.
|
||||
|
@ -231,3 +239,11 @@ _ecore_animator(void *data __UNUSED__)
|
|||
}
|
||||
return ECORE_CALLBACK_RENEW;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -20,6 +20,18 @@
|
|||
static int app_argc = 0;
|
||||
static char **app_argv = NULL;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Application_Group Ecore Application functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Set up the programs command-line arguments.
|
||||
* @param argc The same as passed as argc to the programs main() function
|
||||
|
@ -75,3 +87,11 @@ ecore_app_restart(void)
|
|||
args[i] = NULL;
|
||||
execvp(app_argv[0], args);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -70,6 +70,18 @@ static void _ecore_event_purge_deleted(void);
|
|||
static void *_ecore_event_del(Ecore_Event *event);
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Event_Group Ecore Event functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Add an event handler.
|
||||
* @param type The type of the event this handler will get called for
|
||||
|
@ -333,6 +345,14 @@ ecore_event_current_event_get(void)
|
|||
return ecore_raw_event_event;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_event_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -299,10 +299,19 @@ _ecore_exe_check_errno(int result, const char *file, int line)
|
|||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Exe_Basic_Group Process Spawning Functions
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* Functions that deal with spawned processes.
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Exe_Group Process Spawning Functions
|
||||
*
|
||||
* Functions that deal with and send signals to spawned processes.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
static int run_pri = ECORE_EXE_PRIORITY_INHERIT;
|
||||
|
@ -322,7 +331,6 @@ static int run_pri = ECORE_EXE_PRIORITY_INHERIT;
|
|||
*
|
||||
* @param pri value a Ecore_Exe_Win32_Priority value on Windows, -20
|
||||
* to 19 or ECORE_EXE_PRIORITY_INHERIT on other OS.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_run_priority_set(int pri)
|
||||
|
@ -338,7 +346,6 @@ ecore_exe_run_priority_set(int pri)
|
|||
* by this call.
|
||||
*
|
||||
* @return the value set by ecore_exe_run_priority_set()
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI int
|
||||
ecore_exe_run_priority_get(void)
|
||||
|
@ -354,7 +361,6 @@ ecore_exe_run_priority_get(void)
|
|||
* @param exe_cmd The command to run with @c /bin/sh.
|
||||
* @param data Data to attach to the returned process handle.
|
||||
* @return A process handle to the spawned process.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI Ecore_Exe *
|
||||
ecore_exe_run(const char *exe_cmd, const void *data)
|
||||
|
@ -386,7 +392,6 @@ ecore_exe_run(const char *exe_cmd, const void *data)
|
|||
* @param flags The flag parameters for how to deal with inter-process I/O
|
||||
* @param data Data to attach to the returned process handle.
|
||||
* @return A process handle to the spawned process.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI Ecore_Exe *
|
||||
ecore_exe_pipe_run(const char *exe_cmd, Ecore_Exe_Flags flags, const void *data)
|
||||
|
@ -702,7 +707,6 @@ ecore_exe_callback_pre_free_set(Ecore_Exe *exe, Ecore_Exe_Cb func)
|
|||
* @param data The data to send
|
||||
* @param size The size of the data to send, in bytes
|
||||
* @return EINA_TRUE if successful, EINA_FALSE on failure.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
ecore_exe_send(Ecore_Exe * exe, const void *data, int size)
|
||||
|
@ -746,7 +750,6 @@ ecore_exe_send(Ecore_Exe * exe, const void *data, int size)
|
|||
* The stdin of the given child process will close when the write buffer is empty.
|
||||
*
|
||||
* @param exe The child process
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_close_stdin(Ecore_Exe *exe)
|
||||
|
@ -768,7 +771,6 @@ ecore_exe_close_stdin(Ecore_Exe *exe)
|
|||
* @param end_bytes limit of bytes at end of output to buffer.
|
||||
* @param start_lines limit of lines at start of output to buffer.
|
||||
* @param end_lines limit of lines at end of output to buffer.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_auto_limits_set(Ecore_Exe *exe, int start_bytes, int end_bytes, int start_lines, int end_lines)
|
||||
|
@ -829,7 +831,6 @@ ecore_exe_auto_limits_set(Ecore_Exe *exe, int start_bytes, int end_bytes, int st
|
|||
*
|
||||
* @param exe The given process handle.
|
||||
* @param flags Is this a ECORE_EXE_PIPE_READ or ECORE_EXE_PIPE_ERROR?
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI Ecore_Exe_Event_Data *
|
||||
ecore_exe_event_data_get(Ecore_Exe *exe, Ecore_Exe_Flags flags)
|
||||
|
@ -960,7 +961,6 @@ ecore_exe_event_data_get(Ecore_Exe *exe, Ecore_Exe_Flags flags)
|
|||
*
|
||||
* @param exe The given process handle.
|
||||
* @param tag The string tag to set on the process handle.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_tag_set(Ecore_Exe *exe, const char *tag)
|
||||
|
@ -987,7 +987,6 @@ ecore_exe_tag_set(Ecore_Exe *exe, const char *tag)
|
|||
* @return The string attached to @p exe. It is a handle to existing
|
||||
* internal string and should not be modified, use
|
||||
* ecore_exe_tag_set() to change it. It might be @c NULL.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI const char *
|
||||
ecore_exe_tag_get(const Ecore_Exe *exe)
|
||||
|
@ -1009,7 +1008,6 @@ ecore_exe_tag_get(const Ecore_Exe *exe)
|
|||
* @param exe The given process handle.
|
||||
* @return The data attached to the handle when @ref ecore_exe_run was
|
||||
* called.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_exe_free(Ecore_Exe *exe)
|
||||
|
@ -1074,7 +1072,6 @@ ecore_exe_free(Ecore_Exe *exe)
|
|||
* Frees the given event data.
|
||||
*
|
||||
* @param e The given event data.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
|
||||
|
@ -1089,7 +1086,6 @@ ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
|
|||
* Retrieves the process ID of the given spawned process.
|
||||
* @param exe Handle to the given spawned process.
|
||||
* @return The process ID on success. @c -1 otherwise.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI pid_t
|
||||
ecore_exe_pid_get(const Ecore_Exe *exe)
|
||||
|
@ -1108,7 +1104,6 @@ ecore_exe_pid_get(const Ecore_Exe *exe)
|
|||
* @return The command on success. NULL otherwise. This string is the
|
||||
* pointer to the internal value and must not be modified in
|
||||
* any way.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI const char *
|
||||
ecore_exe_cmd_get(const Ecore_Exe *exe)
|
||||
|
@ -1126,7 +1121,6 @@ ecore_exe_cmd_get(const Ecore_Exe *exe)
|
|||
* @param exe The given process handle.
|
||||
* @return The data pointer attached to @p exe Given to
|
||||
* ecore_exe_run() or ecore_exe_pipe_run()
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_exe_data_get(const Ecore_Exe *exe)
|
||||
|
@ -1143,7 +1137,6 @@ ecore_exe_data_get(const Ecore_Exe *exe)
|
|||
* Retrieves the flags attached to the given process handle.
|
||||
* @param exe The given process handle.
|
||||
* @return The flags attached to @p exe.
|
||||
* @ingroup Ecore_Exe_Basic_Group
|
||||
*/
|
||||
EAPI Ecore_Exe_Flags
|
||||
ecore_exe_flags_get(const Ecore_Exe *exe)
|
||||
|
@ -1156,16 +1149,9 @@ ecore_exe_flags_get(const Ecore_Exe *exe)
|
|||
return exe->flags;
|
||||
}
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Exe_Signal_Group Spawned Process Signal Functions
|
||||
*
|
||||
* Functions that send signals to spawned processes.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Pauses the given process by sending it a @c SIGSTOP signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_pause(Ecore_Exe *exe)
|
||||
|
@ -1181,7 +1167,6 @@ ecore_exe_pause(Ecore_Exe *exe)
|
|||
/**
|
||||
* Continues the given paused process by sending it a @c SIGCONT signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_continue(Ecore_Exe *exe)
|
||||
|
@ -1197,7 +1182,6 @@ ecore_exe_continue(Ecore_Exe *exe)
|
|||
/**
|
||||
* Sends the given spawned process a interrupt (@c SIGINT) signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_interrupt(Ecore_Exe *exe)
|
||||
|
@ -1214,7 +1198,6 @@ ecore_exe_interrupt(Ecore_Exe *exe)
|
|||
/**
|
||||
* Sends the given spawned process a quit (@c SIGQUIT) signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_quit(Ecore_Exe *exe)
|
||||
|
@ -1231,7 +1214,6 @@ ecore_exe_quit(Ecore_Exe *exe)
|
|||
/**
|
||||
* Sends the given spawned process a terminate (@c SIGTERM) signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_terminate(Ecore_Exe *exe)
|
||||
|
@ -1249,7 +1231,6 @@ ecore_exe_terminate(Ecore_Exe *exe)
|
|||
/**
|
||||
* Kills the given spawned process by sending it a @c SIGKILL signal.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_kill(Ecore_Exe *exe)
|
||||
|
@ -1281,7 +1262,6 @@ ecore_exe_kill(Ecore_Exe *exe)
|
|||
* @param exe Process handle to the given process.
|
||||
* @param num The number user signal to send. Must be either 1 or 2, or
|
||||
* the signal will be ignored.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_signal(Ecore_Exe *exe, int num)
|
||||
|
@ -1300,7 +1280,6 @@ ecore_exe_signal(Ecore_Exe *exe, int num)
|
|||
/**
|
||||
* Sends a @c SIGHUP signal to the given spawned process.
|
||||
* @param exe Process handle to the given process.
|
||||
* @ingroup Ecore_Exe_Signal_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_exe_hup(Ecore_Exe *exe)
|
||||
|
@ -1313,6 +1292,14 @@ ecore_exe_hup(Ecore_Exe *exe)
|
|||
kill(exe->pid, SIGHUP);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
static Ecore_Exe *
|
||||
_ecore_exe_is_it_alive(pid_t pid)
|
||||
{
|
||||
|
|
|
@ -219,6 +219,18 @@ _ecore_glib_shutdown(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Main_Loop_Group Ecore Main Loop functions
|
||||
*
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* Request ecore to integrate GLib's main loop.
|
||||
*
|
||||
|
@ -284,3 +296,11 @@ ecore_main_loop_glib_always_integrate_disable(void)
|
|||
{
|
||||
_ecore_glib_always_integrate = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -23,13 +23,24 @@ static Ecore_Idle_Enterer *idle_enterers = NULL;
|
|||
static Ecore_Idle_Enterer *idle_enterer_current = NULL;
|
||||
static int idle_enterers_delete_me = 0;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Idle_Group Ecore Idle functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Add an idle enterer handler.
|
||||
* @param func The function to call when entering an idle state.
|
||||
* @param data The data to be passed to the @p func call
|
||||
* @return A handle to the idle enterer callback if successful. Otherwise,
|
||||
* NULL is returned.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI Ecore_Idle_Enterer *
|
||||
ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data)
|
||||
|
@ -52,7 +63,6 @@ ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data)
|
|||
* @param data The data to be passed to the @p func call
|
||||
* @return A handle to the idle enterer callback if successful. Otherwise,
|
||||
* NULL is returned.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI Ecore_Idle_Enterer *
|
||||
ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data)
|
||||
|
@ -74,7 +84,6 @@ ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data)
|
|||
* @param idle_enterer The idle enterer to delete
|
||||
* @return The data pointer passed to the idler enterer callback on success.
|
||||
* NULL otherwise.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer)
|
||||
|
@ -91,6 +100,14 @@ ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer)
|
|||
return idle_enterer->data;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_idle_enterer_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -23,12 +23,23 @@ static Ecore_Idle_Exiter *idle_exiters = NULL;
|
|||
static Ecore_Idle_Exiter *idle_exiter_current = NULL;
|
||||
static int idle_exiters_delete_me = 0;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Idle_Group Ecore Idle functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* 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.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI Ecore_Idle_Exiter *
|
||||
ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data)
|
||||
|
@ -50,7 +61,6 @@ ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data)
|
|||
* @param idle_exiter The idle exiter to delete
|
||||
* @return The data pointer that was being being passed to the handler if
|
||||
* successful. NULL otherwise.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
|
||||
|
@ -67,6 +77,14 @@ ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
|
|||
return idle_exiter->data;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_idle_exiter_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -23,12 +23,46 @@ static Ecore_Idler *idlers = NULL;
|
|||
static Ecore_Idler *idler_current = NULL;
|
||||
static int idlers_delete_me = 0;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Idle_Group Ecore Idle functions
|
||||
*
|
||||
Callbacks that are called when the program enters or exits an idle state.
|
||||
|
||||
The ecore main loop enters an idle state when it is waiting for timers
|
||||
to time out, data to come in on a file descriptor or any other event
|
||||
to occur. You can set callbacks to be called when the main loop
|
||||
enters an idle state, during an idle state or just after the program
|
||||
wakes up.
|
||||
|
||||
Enterer callbacks are good for updating your program's state, if it
|
||||
has a state engine. Once all of the enterer handlers are called, the
|
||||
program will enter a "sleeping" state.
|
||||
|
||||
Idler callbacks are called when the main loop has called all enterer
|
||||
handlers. They are useful for interfaces that require polling and
|
||||
timers would be too slow to use.
|
||||
|
||||
If no idler callbacks are specified, then the process literally goes
|
||||
to sleep. Otherwise, the idler callbacks are called continuously
|
||||
while the loop is "idle", using as much CPU as is available to the
|
||||
process.
|
||||
|
||||
Exiter callbacks are called when the main loop wakes up from an idle
|
||||
state.
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* 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. NULL otherwise.
|
||||
* @ingroup Idle_Group
|
||||
*
|
||||
* Add an idler handle to the event loop, returning a handle on success and
|
||||
* NULL otherwise. The function @p func will be called repeatedly while
|
||||
|
@ -58,7 +92,6 @@ ecore_idler_add(Ecore_Task_Cb func, const void *data)
|
|||
* @param idler The handle of the idler callback to delete
|
||||
* @return The data pointer passed to the idler callback on success. NULL
|
||||
* otherwise.
|
||||
* @ingroup Idle_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_idler_del(Ecore_Idler *idler)
|
||||
|
@ -75,6 +108,14 @@ ecore_idler_del(Ecore_Idler *idler)
|
|||
return idler->data;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_idler_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -35,6 +35,21 @@ _ecore_job_shutdown(void)
|
|||
_ecore_job_handler = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Job_Group Ecore Job functions
|
||||
*
|
||||
* You can queue jobs that are to be done by the main loop when the current
|
||||
* event is dealt with.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Add a job to the event queue.
|
||||
* @param func The function to call when the job gets handled.
|
||||
|
@ -42,7 +57,6 @@ _ecore_job_shutdown(void)
|
|||
* handled.
|
||||
* @return The handle of the job. @c NULL is returned if the job could not be
|
||||
* added to the queue.
|
||||
* @ingroup Ecore_Job_Group
|
||||
* @note Once the job has been executed, the job handle is invalid.
|
||||
*/
|
||||
EAPI Ecore_Job *
|
||||
|
@ -70,7 +84,6 @@ ecore_job_add(Ecore_Cb func, const void *data)
|
|||
* Delete a queued job that has not yet been executed.
|
||||
* @param job Handle of the job to delete.
|
||||
* @return The data pointer that was to be passed to the job.
|
||||
* @ingroup Ecore_Job_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_job_del(Ecore_Job *job)
|
||||
|
@ -89,6 +102,14 @@ ecore_job_del(Ecore_Job *job)
|
|||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
static Eina_Bool
|
||||
_ecore_job_event_handler(void *data __UNUSED__, int type __UNUSED__, void *ev)
|
||||
{
|
||||
|
|
|
@ -517,9 +517,14 @@ _ecore_main_loop_shutdown(void)
|
|||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Main_Loop_Group Main Loop Functions
|
||||
* @addtogroup Ecore_Main_Loop_Group Ecore Main Loop functions
|
||||
*
|
||||
* These functions control the Ecore event handling loop. This loop is
|
||||
* designed to work on embedded systems all the way to large and
|
||||
|
@ -536,12 +541,13 @@ _ecore_main_loop_shutdown(void)
|
|||
*
|
||||
* For examples of setting up and using a main loop, see
|
||||
* @ref event_handler_example.c and @ref timer_example.c.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Runs a single iteration of the main loop to process everything on the
|
||||
* queue.
|
||||
* @ingroup Ecore_Main_Loop_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_main_loop_iterate(void)
|
||||
|
@ -558,7 +564,6 @@ ecore_main_loop_iterate(void)
|
|||
*
|
||||
* This function will not return until @ref ecore_main_loop_quit is called.
|
||||
*
|
||||
* @ingroup Ecore_Main_Loop_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_main_loop_begin(void)
|
||||
|
@ -577,7 +582,6 @@ ecore_main_loop_begin(void)
|
|||
/**
|
||||
* Quits the main loop once all the events currently on the queue have
|
||||
* been processed.
|
||||
* @ingroup Ecore_Main_Loop_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_main_loop_quit(void)
|
||||
|
@ -602,7 +606,6 @@ ecore_main_loop_quit(void)
|
|||
*
|
||||
* @warning you don't know how to use, don't even try to use it.
|
||||
*
|
||||
* @ingroup Ecore_Main_Loop_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_main_loop_select_func_set(Ecore_Select_Function func)
|
||||
|
@ -614,7 +617,6 @@ ecore_main_loop_select_func_set(Ecore_Select_Function func)
|
|||
* Gets the select function set by ecore_select_func_set(),
|
||||
* or the native select function if none was set.
|
||||
*
|
||||
* @ingroup Ecore_Main_Loop_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_main_loop_select_func_get(void)
|
||||
|
@ -850,6 +852,14 @@ ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_main_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -67,7 +67,13 @@ struct _Ecore_Pipe
|
|||
static Eina_Bool _ecore_pipe_read(void *data, Ecore_Fd_Handler *fd_handler);
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Pipe_Group Pipe wrapper
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Pipe_Group Pipe wrapper
|
||||
*
|
||||
* These functions wrap the pipe / write / read functions to
|
||||
* easily integrate a loop that is in its own thread to the ecore
|
||||
|
@ -277,7 +283,6 @@ static Eina_Bool _ecore_pipe_read(void *data, Ecore_Fd_Handler *fd_handler);
|
|||
* @param data Data to pass to @p handler when it is called.
|
||||
* @return A newly created Ecore_Pipe object if successful.
|
||||
* @c NULL otherwise.
|
||||
* @ingroup Ecore_Pipe_Group
|
||||
*/
|
||||
EAPI Ecore_Pipe *
|
||||
ecore_pipe_add(Ecore_Pipe_Cb handler, const void *data)
|
||||
|
@ -316,7 +321,6 @@ ecore_pipe_add(Ecore_Pipe_Cb handler, const void *data)
|
|||
*
|
||||
* @param p The Ecore_Pipe object to be freed.
|
||||
* @return The pointer to the private data
|
||||
* @ingroup Ecore_Pipe_Group
|
||||
*/
|
||||
EAPI void *
|
||||
ecore_pipe_del(Ecore_Pipe *p)
|
||||
|
@ -342,7 +346,6 @@ ecore_pipe_del(Ecore_Pipe *p)
|
|||
* Close the read end of an Ecore_Pipe object created with ecore_pipe_add().
|
||||
*
|
||||
* @param p The Ecore_Pipe object.
|
||||
* @ingroup Ecore_Pipe_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_pipe_read_close(Ecore_Pipe *p)
|
||||
|
@ -368,7 +371,6 @@ ecore_pipe_read_close(Ecore_Pipe *p)
|
|||
* Close the write end of an Ecore_Pipe object created with ecore_pipe_add().
|
||||
*
|
||||
* @param p The Ecore_Pipe object.
|
||||
* @ingroup Ecore_Pipe_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_pipe_write_close(Ecore_Pipe *p)
|
||||
|
@ -392,7 +394,6 @@ ecore_pipe_write_close(Ecore_Pipe *p)
|
|||
* @param buffer The data to write into the pipe.
|
||||
* @param nbytes The size of the @p buffer in bytes
|
||||
* @return Returns EINA_TRUE on a successful write, EINA_FALSE on an error
|
||||
* @ingroup Ecore_Pipe_Group
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
ecore_pipe_write(Ecore_Pipe *p, const void *buffer, unsigned int nbytes)
|
||||
|
@ -482,6 +483,14 @@ ecore_pipe_write(Ecore_Pipe *p, const void *buffer, unsigned int nbytes)
|
|||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/* Private function */
|
||||
static void
|
||||
_ecore_pipe_unhandle(Ecore_Pipe *p)
|
||||
|
|
|
@ -191,12 +191,20 @@ _ecore_poller_cb_timer(void *data __UNUSED__)
|
|||
}
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Poll_Group Ecore Poll Functions
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Poller_Group Ecore Poll functions
|
||||
*
|
||||
* These functions are for the need to poll information, but provide a shared
|
||||
* abstracted API to pool such polling to minimise wakeup and ensure all the
|
||||
* polling happens in as few spots as possible areound a core poll interval.
|
||||
* For now only 1 core poller type is supprted: ECORE_POLLER_CORE
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
|
@ -204,7 +212,6 @@ _ecore_poller_cb_timer(void *data __UNUSED__)
|
|||
* Sets the time between ticks (in seconds) for the given ticker clock.
|
||||
* @param type The ticker type to adjust
|
||||
* @param poll_time The time (in seconds) between ticks of the clock
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*
|
||||
* This will adjust the time between ticks of the given ticker type defined
|
||||
* by @p type to the time period defined by @p poll_time.
|
||||
|
@ -220,7 +227,6 @@ ecore_poller_poll_interval_set(Ecore_Poller_Type type __UNUSED__, double poll_ti
|
|||
* Gets the time between ticks (in seconds) for the given ticker clock.
|
||||
* @param type The ticker type to query
|
||||
* @return The time in seconds between ticks of the ticker clock
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*
|
||||
* This will get the time between ticks of the specifider ticker clock.
|
||||
*/
|
||||
|
@ -238,7 +244,6 @@ ecore_poller_poll_interval_get(Ecore_Poller_Type type __UNUSED__)
|
|||
* rescheduled for the next tick interval.
|
||||
* @param data Data to pass to @p func when it is called.
|
||||
* @return A poller object on success. @c NULL on failure.
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*
|
||||
* This function adds a poller callback that is to be called regularly
|
||||
* along with all other poller callbacks so the pollers are synchronized with
|
||||
|
@ -320,7 +325,6 @@ ecore_poller_add(Ecore_Poller_Type type __UNUSED__, int interval, Ecore_Task_Cb
|
|||
*
|
||||
* 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.
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*/
|
||||
EAPI Eina_Bool
|
||||
ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval)
|
||||
|
@ -364,7 +368,6 @@ ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval)
|
|||
* @return Returns the interval, in ticks, that @p poller polls at
|
||||
*
|
||||
* This returns a poller's polling interval, or 0 on error.
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*/
|
||||
EAPI int
|
||||
ecore_poller_poller_interval_get(Ecore_Poller *poller)
|
||||
|
@ -392,7 +395,6 @@ ecore_poller_poller_interval_get(Ecore_Poller *poller)
|
|||
* @param poller The poller to delete.
|
||||
* @return The data pointer set for the timer when @ref ecore_poller_add was
|
||||
* called. @c NULL is returned if the function is unsuccessful.
|
||||
* @ingroup Ecore_Poller_Group
|
||||
*
|
||||
* Note: @p 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 delete).
|
||||
|
@ -425,6 +427,14 @@ ecore_poller_del(Ecore_Poller *poller)
|
|||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_poller_shutdown(void)
|
||||
{
|
||||
|
|
|
@ -430,9 +430,18 @@ _ecore_thread_shutdown(void)
|
|||
del_handler = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Thread Ecore Thread Functions
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Thread_Group Ecore Thread functions
|
||||
*
|
||||
* These functions allow for ecore-managed threads which integrate with ecore's main loop.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
@ -1330,3 +1339,7 @@ ecore_thread_global_data_wait(const char *key, double seconds)
|
|||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
|
|
@ -22,6 +22,18 @@ static clockid_t _ecore_time_clock_id = -1;
|
|||
#endif
|
||||
double _ecore_time_loop_time = -1.0;
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Time_Group Ecore Time functions
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* Retrieves the current system time as a floating point value in seconds.
|
||||
*
|
||||
|
@ -36,7 +48,6 @@ double _ecore_time_loop_time = -1.0;
|
|||
* when the machine was booted, unix time, etc), all it is
|
||||
* defined is that it never goes backwards (unless you got big critical
|
||||
* messages when the application started).
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI double
|
||||
ecore_time_get(void)
|
||||
|
@ -67,7 +78,6 @@ ecore_time_get(void)
|
|||
* @see ecore_loop_time_get().
|
||||
*
|
||||
* @return The number of seconds since 12.00AM 1st January 1970.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI double
|
||||
ecore_time_unix_get(void)
|
||||
|
@ -106,7 +116,6 @@ ecore_time_unix_get(void)
|
|||
* when the machine was booted, unix time, etc), all it is
|
||||
* defined is that it never goes backwards (unless you got big critical
|
||||
* messages when the application started).
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI double
|
||||
ecore_loop_time_get(void)
|
||||
|
@ -114,6 +123,14 @@ ecore_loop_time_get(void)
|
|||
return _ecore_time_loop_time;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
/********************** Internal methods ********************************/
|
||||
|
||||
|
|
|
@ -37,10 +37,20 @@ static double last_check = 0.0;
|
|||
static double precision = 10.0 / 1000000.0;
|
||||
|
||||
/**
|
||||
* @defgroup Ecore_Time_Group Ecore Time Functions
|
||||
* @addtogroup Ecore_Group Ecore - Main Loop and Job Functions.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @addtogroup Ecore_Time_Group Ecore Time functions
|
||||
*
|
||||
* Functions that deal with time. These functions include those that simply
|
||||
* retrieve it in a given format, and those that create events based on it.
|
||||
*
|
||||
* The timer allows callbacks to be called at specific intervals.
|
||||
*
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
|
@ -96,7 +106,6 @@ ecore_timer_precision_set(double value)
|
|||
* 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.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*
|
||||
* 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
|
||||
|
@ -131,7 +140,6 @@ ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
|
|||
* 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.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*
|
||||
* This is the same as ecore_timer_add(), but "now" is the time from
|
||||
* ecore_loop_time_get() not ecore_time_get() as ecore_timer_add() uses. See
|
||||
|
@ -158,7 +166,6 @@ ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data)
|
|||
* @param timer The timer to delete.
|
||||
* @return The data pointer set for the timer when @ref ecore_timer_add was
|
||||
* called. @c NULL is returned if the function is unsuccessful.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*
|
||||
* Note: @p timer must be a valid handle. If the timer function has already
|
||||
* returned 0, the handle is no longer valid (and does not need to be delete).
|
||||
|
@ -198,7 +205,6 @@ ecore_timer_del(Ecore_Timer *timer)
|
|||
*
|
||||
* @param timer The timer to change.
|
||||
* @param in The interval in seconds.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_timer_interval_set(Ecore_Timer *timer, double in)
|
||||
|
@ -217,7 +223,6 @@ ecore_timer_interval_set(Ecore_Timer *timer, double in)
|
|||
*
|
||||
* @param timer The timer to retrieve the interval from
|
||||
* @return The interval on success. -1 on failure.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI double
|
||||
ecore_timer_interval_get(Ecore_Timer *timer)
|
||||
|
@ -238,7 +243,6 @@ ecore_timer_interval_get(Ecore_Timer *timer)
|
|||
*
|
||||
* @param timer The timer to change.
|
||||
* @param add The dalay to add to the next iteration.
|
||||
* @ingroup Ecore_Time_Group
|
||||
*/
|
||||
EAPI void
|
||||
ecore_timer_delay(Ecore_Timer *timer, double add)
|
||||
|
@ -338,6 +342,14 @@ ecore_timer_thaw(Ecore_Timer *timer)
|
|||
_ecore_timer_set(timer, timer->pending + now, timer->in, timer->func, timer->data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
void
|
||||
_ecore_timer_shutdown(void)
|
||||
{
|
||||
|
|
Loading…
Reference in New Issue