2011-05-24 04:31:32 -07:00
/**
@ brief Ecore Library Public API Calls
These routines are used for Ecore Library interaction
*/
/**
@ mainpage Ecore
@ image html e . png
@ version @ PACKAGE_VERSION @
@ author Carsten Haitzler < raster @ rasterman . com >
@ author Tom Gilbert < tom @ linuxbrit . co . uk >
@ author Burra < burra @ colorado . edu >
@ author Chris Ross < chris @ darkrock . co . uk >
@ author Term < term @ twistedpath . org >
@ author Tilman Sauerbeck < tilman @ code - monkey . de >
@ author Ibukun Olumuyiwa < ibukun @ computer . org >
@ author Yuri < da2001 @ hotmail . ru >
@ author Nicholas Curran < quasar @ bigblue . net . au >
@ author Howell Tam < pigeon @ pigeond . net >
@ author Nathan Ingersoll < rbdpngn @ users . sourceforge . net >
@ author Andrew Elcock < andy @ elcock . org >
@ author Kim Woelders < kim @ woelders . dk >
@ author Sebastian Dransfeld < sebastid @ tango . flipp . net >
@ author Simon Poole < simon . armlinux @ themalago . net >
@ author Jorge Luis Zapata Muga < jorgeluis . zapata @ gmail . com >
@ author dan sinclair < zero @ everburning . com >
@ author Michael ' Mickey ' Lauer < mickey @ tm . informatik . uni - frankfurt . de >
@ author David ' onefang ' Seikel < onefang @ gmail . com >
@ author Hisham ' CodeWarrior ' Mardam Bey < hisham @ hisham . cc >
@ author Brian ' rephorm ' Mattern < rephorm @ rephorm . com >
@ author Tim Horton < hortont424 @ gmail . com >
@ author Arnaud de Turckheim ' quarium ' < quarium @ gmail . com >
@ author Matt Barclay < mbarclay @ gmail . com >
@ author Peter Wehrfritz < peter . wehrfritz @ web . de >
@ author Albin " Lutin " Tonnerre < albin . tonnerre @ gmail . com >
@ author Vincent Torri < vincent . torri @ gmail . com >
@ author Lars Munch < lars @ segv . dk >
@ author Andre Dieb < andre . dieb @ gmail . com >
@ author Mathieu Taillefumier < mathieu . taillefumier @ free . fr >
@ author Rui Miguel Silva Seabra < rms @ 1407. org >
@ author Samsung Electronics
@ author Samsung SAIT
@ author Nicolas Aguirre < aguirre . nicolas @ gmail . com >
@ author Brett Nash < nash @ nash . id . au >
@ author Mike Blumenkrantz < mike @ zentific . com >
@ author Leif Middelschulte < leif . middelschulte @ gmail . com >
@ author Mike McCormack < mj . mccormack @ samsung . com >
@ author Sangho Park < gouache95 @ gmail . com >
@ author Jihoon Kim < jihoon48 . kim @ samsung . com > < imfine98 @ gmail . com >
@ author Daniel Juyung Seo < seojuyung2 @ gmail . com > < juyung . seo @ samsung . com >
@ date 2000 - 2011
@ section intro Introduction
2011-06-22 08:00:44 -07:00
Ecore is a library of convenience functions . A brief explanation of how to use
it can be found in @ ref Ecore_Main_Loop_Page .
2011-05-24 04:31:32 -07:00
The Ecore library provides the following modules :
@ li @ ref Ecore_Group
@ li @ ref Ecore_File_Group
@ li @ ref Ecore_Con_Group
@ li @ link Ecore_Evas . h Ecore_Evas - Evas convenience functions . @ endlink
@ li @ ref Ecore_FB_Group
@ li @ link Ecore_Ipc . h Ecore_IPC - Inter Process Communication functions . @ endlink
@ li @ link Ecore_X . h Ecore_X - X Windows System wrapper . @ endlink
@ li @ ref Ecore_Win32_Group
@ li @ ref Ecore_WinCE_Group
2011-06-22 08:01:55 -07:00
For more info on Ecore usage , there are these @ ref Examples .
2011-05-24 04:31:32 -07:00
@ section compiling How to compile using Ecore ?
pkgconfig ( . pc ) files are installed for every ecore module .
Thus , to compile using any of them , you can use something like the following :
@ verbatim
gcc * . c $ ( pkg - config ecore ecore - $ x ecore - $ y [ . . . ] - - cflags - - libs )
@ endverbatim
@ section install How is it installed ?
Suggested configure options for evas for a Linux desktop X display :
@ verbatim
. / configure \
- - enable - ecore - x \
- - enable - ecore - fb \
- - enable - ecore - evas \
- - enable - ecore - evas - gl \
- - enable - ecore - con \
- - enable - ecore - ipc
make CFLAGS = " -O9 -mpentiumpro -march=pentiumpro -mcpu=pentiumpro "
@ endverbatim
@ todo ( 1.0 ) Document API
*/
/*
@ page Ecore_Main_Loop_Page The Ecore Main Loop
@ section intro What is Ecore ?
Ecore is a clean and tiny event loop library with many modules to do lots of
convenient things for a programmer , to save time and effort .
It ' s small and lean , designed to work on embedded systems all the way to
large and powerful multi - cpu workstations . It serialises all system signals ,
events etc . into a single event queue , that is easily processed without
needing to worry about concurrency . A properly written , event - driven program
using this kind of programming doesn ' t need threads , nor has to worry about
concurrency . It turns a program into a state machine , and makes it very
robust and easy to follow .
Ecore gives you other handy primitives , such as timers to tick over for you
and call specified functions at particular times so the programmer can use
this to do things , like animate , or time out on connections or tasks that take
too long etc .
Idle handlers are provided too , as well as calls on entering an idle state
( often a very good time to update the state of the program ) . All events that
enter the system are passed to specific callback functions that the program
sets up to handle those events . Handling them is simple and other Ecore
modules produce more events on the queue , coming from other sources such as
file descriptors etc .
Ecore also lets you have functions called when file descriptors become active
for reading or writing , allowing for streamlined , non - blocking IO .
Here is an example of a simple program and its basic event loop flow :
@ image html prog_flow . png
@ section work How does Ecore work ?
Ecore is very easy to learn and use . All the function calls are designed to
be easy to remember , explicit in describing what they do , and heavily
name - spaced . Ecore programs can start and be very simple .
For example :
@ code
# include <Ecore.h>
int main ( int argc , const char * * argv )
{
ecore_init ( ) ;
ecore_app_args_set ( argc , argv ) ;
ecore_main_loop_begin ( ) ;
ecore_shutdown ( ) ;
return 0 ;
}
@ endcode
This program is very simple and does ' t check for errors , but it does start up
and begin a main loop waiting for events or timers to tick off . This program
doesn ' t set up any , but now we can expand on this simple program a little
more by adding some event handlers and timers .
@ code
# include <Ecore.h>
Ecore_Timer * timer1 = NULL ;
Ecore_Event_Handler * handler1 = NULL ;
double start_time = 0.0 ;
int timer_func ( void * data )
{
printf ( " Tick timer. Sec: %3.2f \n " , ecore_time_get ( ) - start_time ) ;
return 1 ;
}
int exit_func ( void * data , int ev_type , void * ev )
{
Ecore_Event_Signal_Exit * e ;
e = ( Ecore_Event_Signal_Exit * ) ev ;
if ( e - > interrupt ) printf ( " Exit: interrupt \n " ) ;
else if ( e - > quit ) printf ( " Exit: quit \n " ) ;
else if ( e - > terminate ) printf ( " Exit: terminate \n " ) ;
ecore_main_loop_quit ( ) ;
return 1 ;
}
int main ( int argc , const char * * argv )
{
ecore_init ( ) ;
ecore_app_args_set ( argc , argv ) ;
start_time = ecore_time_get ( ) ;
handler1 = ecore_event_handler_add ( ECORE_EVENT_SIGNAL_EXIT , exit_func , NULL ) ;
timer1 = ecore_timer_add ( 0.5 , timer_func , NULL ) ;
ecore_main_loop_begin ( ) ;
ecore_shutdown ( ) ;
return 0 ;
}
@ endcode
In the previous example , we initialize our application and get the time at
which our program has started so we can calculate an offset . We set
up a timer to tick off in 0.5 seconds , and since it returns 1 , will
keep ticking off every 0.5 seconds until it returns 0 , or is deleted
by hand . An event handler is set up to call a function - exit_func ( ) ,
whenever an event of type ECORE_EVENT_SIGNAL_EXIT is received ( CTRL - C
on the command line will cause such an event to happen ) . If this event
occurs it tells you what kind of exit signal was received , and asks
the main loop to quit when it is finished by calling
ecore_main_loop_quit ( ) .
The handles returned by ecore_timer_add ( ) and ecore_event_handler_add ( ) are
only stored here as an example . If you don ' t need to address the timer or
event handler again you don ' t need to store the result , so just call the
function , and don ' t assign the result to any variable .
This program looks slightly more complex than needed to do these simple
things , but in principle , programs don ' t get any more complex . You add more
event handlers , for more events , will have more timers and such , BUT it all
follows the same principles as shown in this example .
*/
/*
@ page Ecore_Config_Page The Enlightened Property Library
The Enlightened Property Library ( Ecore_Config ) is an adbstraction
from the complexities of writing your own configuration . It provides
many features using the Enlightenment 17 development libraries .
To use the library , you :
@ li Set the default values of your properties .
@ li Load the configuration from a file . You must set the default values
first , so that the library knows the correct type of each argument .
The following examples show how to use the Enlightened Property Library :
@ li @ link config_basic_example . c config_basic_example . c @ endlink
@ li @ link config_listener_example . c config_listener_example . c @ endlink
*/
/**
@ page X_Window_System_Page X Window System
The Ecore library includes a wrapper for handling the X window system .
This page briefly explains what the X window system is and various terms
that are used .
*/
2003-09-23 01:09:32 -07:00
# ifndef _ECORE_H
# define _ECORE_H
2010-04-05 01:26:48 -07:00
# ifdef _MSC_VER
# include <Evil.h>
# endif
2009-08-04 02:13:49 -07:00
# include <Eina.h>
2004-11-24 21:18:31 -08:00
# ifdef EAPI
2008-05-25 22:16:34 -07:00
# undef EAPI
2004-11-24 21:18:31 -08:00
# endif
2008-05-25 22:16:34 -07:00
# ifdef _WIN32
# ifdef EFL_ECORE_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif /* ! DLL_EXPORT */
2004-11-24 21:18:31 -08:00
# else
# define EAPI __declspec(dllimport)
2008-05-25 22:16:34 -07:00
# endif /* ! EFL_ECORE_BUILD */
2004-11-24 21:18:31 -08:00
# else
2005-12-27 09:17:31 -08:00
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
2004-11-24 21:18:31 -08:00
# else
# define EAPI
# endif
2008-05-25 22:16:34 -07:00
# endif /* ! _WIN32 */
2004-11-24 21:18:31 -08:00
2009-04-16 10:12:40 -07:00
# ifdef _WIN32
# include <winsock2.h>
2009-10-25 07:48:12 -07:00
# elif (defined (__FreeBSD__) && (__FreeBSD_version >= 420001)) || defined (__OpenBSD__)
2009-07-28 02:58:12 -07:00
# include <sys / select.h>
2009-11-07 11:10:08 -08:00
# include <signal.h>
2009-04-16 10:12:40 -07:00
# else
2009-06-12 08:23:32 -07:00
# include <sys / time.h>
2009-04-16 10:12:40 -07:00
# include <signal.h>
2006-01-09 05:36:22 -08:00
# endif
2010-02-06 14:14:32 -08:00
2009-10-25 00:07:48 -07:00
# include <sys/types.h>
2004-03-17 21:29:54 -08:00
2005-04-14 18:22:46 -07:00
# ifdef __cplusplus
extern " C " {
# endif
2010-10-17 00:03:28 -07:00
/**
2011-01-26 10:23:45 -08:00
* @ file Ecore . h
2010-10-17 00:03:28 -07:00
* @ 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 .
*
* @ {
*/
2010-08-16 01:17:24 -07:00
# define ECORE_VERSION_MAJOR 1
# define ECORE_VERSION_MINOR 0
2010-05-28 23:37:02 -07:00
typedef struct _Ecore_Version
{
int major ;
int minor ;
int micro ;
int revision ;
} Ecore_Version ;
EAPI extern Ecore_Version * ecore_version ;
2010-06-24 09:15:56 -07:00
# define ECORE_CALLBACK_CANCEL EINA_FALSE /**< Return value to remove a callback */
# define ECORE_CALLBACK_RENEW EINA_TRUE /**< Return value to keep a callback */
# define ECORE_CALLBACK_PASS_ON EINA_TRUE /**< Return value to pass event to next handler */
# define ECORE_CALLBACK_DONE EINA_FALSE /**< Return value to stop event handling */
2008-01-25 10:28:16 -08:00
2005-10-24 01:53:50 -07:00
# define ECORE_EVENT_NONE 0
2006-01-13 05:18:36 -08:00
# define ECORE_EVENT_SIGNAL_USER 1 /**< User signal event */
# define ECORE_EVENT_SIGNAL_HUP 2 /**< Hup signal event */
# define ECORE_EVENT_SIGNAL_EXIT 3 /**< Exit signal event */
# define ECORE_EVENT_SIGNAL_POWER 4 /**< Power signal event */
# define ECORE_EVENT_SIGNAL_REALTIME 5 /**< Realtime signal event */
# define ECORE_EVENT_COUNT 6
2008-11-01 18:29:08 -07:00
# define ECORE_EXE_PRIORITY_INHERIT 9999
2006-01-13 05:18:36 -08:00
EAPI extern int ECORE_EXE_EVENT_ADD ; /**< A child process has been added */
2010-09-08 04:23:42 -07:00
EAPI extern int ECORE_EXE_EVENT_DEL ; /**< A child process has been deleted (it exited, naming consistent with the rest of ecore). */
2006-01-13 05:18:36 -08:00
EAPI extern int ECORE_EXE_EVENT_DATA ; /**< Data from a child process. */
EAPI extern int ECORE_EXE_EVENT_ERROR ; /**< Errors from a child process. */
2006-01-12 20:31:41 -08:00
2003-09-23 01:09:32 -07:00
enum _Ecore_Fd_Handler_Flags
{
2010-09-29 23:09:20 -07:00
ECORE_FD_READ = 1 , /**< Fd Read mask */
ECORE_FD_WRITE = 2 , /**< Fd Write mask */
ECORE_FD_ERROR = 4 /**< Fd Error mask */
2003-09-23 01:09:32 -07:00
} ;
typedef enum _Ecore_Fd_Handler_Flags Ecore_Fd_Handler_Flags ;
2007-08-26 04:17:21 -07:00
2005-12-24 04:22:47 -08:00
enum _Ecore_Exe_Flags /* flags for executing a child with its stdin and/or stdout piped back */
2005-10-24 01:53:50 -07:00
{
2011-01-26 19:30:42 -08:00
ECORE_EXE_NONE = 0 , /**< No exe flags at all */
2010-09-29 23:09:20 -07:00
ECORE_EXE_PIPE_READ = 1 , /**< Exe Pipe Read mask */
ECORE_EXE_PIPE_WRITE = 2 , /**< Exe Pipe Write mask */
ECORE_EXE_PIPE_ERROR = 4 , /**< Exe Pipe error mask */
ECORE_EXE_PIPE_READ_LINE_BUFFERED = 8 , /**< Reads are buffered until a newline and delivered 1 event per line */
ECORE_EXE_PIPE_ERROR_LINE_BUFFERED = 16 , /**< Errors are buffered until a newline and delivered 1 event per line */
ECORE_EXE_PIPE_AUTO = 32 , /**< stdout and stderr are buffered automatically */
ECORE_EXE_RESPAWN = 64 , /**< FIXME: Exe is restarted if it dies */
ECORE_EXE_USE_SH = 128 , /**< Use /bin/sh to run the command. */
ECORE_EXE_NOT_LEADER = 256 /**< Do not use setsid() to have the executed process be its own session leader */
2005-10-24 01:53:50 -07:00
} ;
typedef enum _Ecore_Exe_Flags Ecore_Exe_Flags ;
2007-08-26 04:17:21 -07:00
2010-02-20 01:20:04 -08:00
enum _Ecore_Exe_Win32_Priority
{
ECORE_EXE_WIN32_PRIORITY_IDLE , /**< Idle priority, for monitoring the system */
ECORE_EXE_WIN32_PRIORITY_BELOW_NORMAL , /**< Below default priority */
ECORE_EXE_WIN32_PRIORITY_NORMAL , /**< Default priority */
ECORE_EXE_WIN32_PRIORITY_ABOVE_NORMAL , /**< Above default priority */
ECORE_EXE_WIN32_PRIORITY_HIGH , /**< High priority, use with care as other threads in the system will not get processor time */
ECORE_EXE_WIN32_PRIORITY_REALTIME /**< Realtime priority, should be almost never used as it can interrupt system threads that manage mouse input, keyboard input, and background disk flushing */
} ;
typedef enum _Ecore_Exe_Win32_Priority Ecore_Exe_Win32_Priority ;
2008-01-10 23:33:57 -08:00
enum _Ecore_Poller_Type /* Poller types */
{
2010-09-29 23:09:20 -07:00
ECORE_POLLER_CORE = 0 /**< The core poller interval */
2008-01-10 23:33:57 -08:00
} ;
typedef enum _Ecore_Poller_Type Ecore_Poller_Type ;
2011-04-19 23:51:39 -07:00
enum _Ecore_Pos_Map /* Position mappings */
{
ECORE_POS_MAP_LINEAR , /**< Linear 0.0 -> 1.0 */
ECORE_POS_MAP_ACCELERATE , /**< Start slow then speed up */
ECORE_POS_MAP_DECELERATE , /**< Start fast then slow down */
ECORE_POS_MAP_SINUSOIDAL , /**< Start slow, speed up then slow down at end */
ECORE_POS_MAP_ACCELERATE_FACTOR , /**< Start slow then speed up, v1 being a power factor, 0.0 being linear, 1.0 being normal accelerate, 2.0 being much more pronounced accelerate (squared), 3.0 being cubed, etc. */
ECORE_POS_MAP_DECELERATE_FACTOR , /**< Start fast then slow down, v1 being a power factor, 0.0 being linear, 1.0 being normal decelerate, 2.0 being much more pronounced decelerate (squared), 3.0 being cubed, etc. */
ECORE_POS_MAP_SINUSOIDAL_FACTOR , /**< Start slow, speed up then slow down at end, v1 being a power factor, 0.0 being linear, 1.0 being normal sinusoidal, 2.0 being much more pronounced sinusoidal (squared), 3.0 being cubed, etc. */
ECORE_POS_MAP_DIVISOR_INTERP , /**< Start at gradient * v1, interpolated via power of v2 curve */
ECORE_POS_MAP_BOUNCE , /**< Start at 0.0 then "drop" like a ball bouncing to the ground at 1.0, and bounce v2 times, with decay factor of v1 */
ECORE_POS_MAP_SPRING /**< Start at 0.0 then "wobble" like a sping rest position 1.0, and wobble v2 times, with decay factor of v1 */
} ;
typedef enum _Ecore_Pos_Map Ecore_Pos_Map ;
2008-05-25 22:31:20 -07:00
2011-05-12 02:11:36 -07:00
enum _Ecore_Animator_Source /* Timing sources for animators */
{
ECORE_ANIMATOR_SOURCE_TIMER , /**< The default system clock/timer based animator that ticks every "frametime" seconds */
ECORE_ANIMATOR_SOURCE_CUSTOM /**< A custom animator trigger that you need to call ecore_animator_trigger() to make it tick */
} ;
typedef enum _Ecore_Animator_Source Ecore_Animator_Source ;
2009-12-22 13:15:12 -08:00
typedef struct _Ecore_Exe Ecore_Exe ; /**< A handle for spawned processes */
typedef struct _Ecore_Timer Ecore_Timer ; /**< A handle for timers */
typedef struct _Ecore_Idler Ecore_Idler ; /**< A handle for idlers */
typedef struct _Ecore_Idle_Enterer Ecore_Idle_Enterer ; /**< A handle for idle enterers */
typedef struct _Ecore_Idle_Exiter Ecore_Idle_Exiter ; /**< A handle for idle exiters */
typedef struct _Ecore_Fd_Handler Ecore_Fd_Handler ; /**< A handle for Fd handlers */
typedef struct _Ecore_Win32_Handler Ecore_Win32_Handler ; /**< A handle for HANDLE handlers on Windows */
typedef struct _Ecore_Event_Handler Ecore_Event_Handler ; /**< A handle for an event handler */
typedef struct _Ecore_Event_Filter Ecore_Event_Filter ; /**< A handle for an event filter */
typedef struct _Ecore_Event Ecore_Event ; /**< A handle for an event */
typedef struct _Ecore_Animator Ecore_Animator ; /**< A handle for animators */
typedef struct _Ecore_Pipe Ecore_Pipe ; /**< A handle for pipes */
typedef struct _Ecore_Poller Ecore_Poller ; /**< A handle for pollers */
2005-10-24 01:53:50 -07:00
typedef struct _Ecore_Event_Signal_User Ecore_Event_Signal_User ; /**< User signal event */
typedef struct _Ecore_Event_Signal_Hup Ecore_Event_Signal_Hup ; /**< Hup signal event */
typedef struct _Ecore_Event_Signal_Exit Ecore_Event_Signal_Exit ; /**< Exit signal event */
typedef struct _Ecore_Event_Signal_Power Ecore_Event_Signal_Power ; /**< Power signal event */
2004-04-04 12:53:19 -07:00
typedef struct _Ecore_Event_Signal_Realtime Ecore_Event_Signal_Realtime ; /**< Realtime signal event */
2006-01-15 03:27:19 -08:00
typedef struct _Ecore_Exe_Event_Add Ecore_Exe_Event_Add ; /**< Spawned Exe add event */
typedef struct _Ecore_Exe_Event_Del Ecore_Exe_Event_Del ; /**< Spawned Exe exit event */
typedef struct _Ecore_Exe_Event_Data_Line Ecore_Exe_Event_Data_Line ; /**< Lines from a child process */
typedef struct _Ecore_Exe_Event_Data Ecore_Exe_Event_Data ; /**< Data from a child process */
2009-11-06 14:15:04 -08:00
typedef struct _Ecore_Thread Ecore_Thread ;
2010-08-03 19:55:20 -07:00
/**
* @ typedef Ecore_Data_Cb Ecore_Data_Cb
* A callback which is used to return data to the main function
*/
typedef void * ( * Ecore_Data_Cb ) ( void * data ) ;
/**
* @ typedef Ecore_Filter_Cb
* A callback used for filtering events from the main loop .
*/
typedef Eina_Bool ( * Ecore_Filter_Cb ) ( void * data , void * loop_data , int type , void * event ) ;
/**
* @ typedef Ecore_Eselect_Function Ecore_Eselect_Function
* A function which can be used to replace select ( ) in the main loop
*/
typedef int ( * Ecore_Select_Function ) ( int nfds , fd_set * readfds , fd_set * writefds , fd_set * exceptfds , struct timeval * timeout ) ;
/**
* @ typedef Ecore_End_Cb Ecore_End_Cb
* This is the callback which is called at the end of a function , usually for cleanup purposes .
*/
typedef void ( * Ecore_End_Cb ) ( void * user_data , void * func_data ) ;
/**
* @ typedef Ecore_Pipe_Cb Ecore_Pipe_Cb
* The callback that data written to the pipe is sent to .
*/
typedef void ( * Ecore_Pipe_Cb ) ( void * data , void * buffer , unsigned int nbyte ) ;
/**
* @ typedef Ecore_Exe_Cb Ecore_Exe_Cb
* A callback to run with the associated @ ref Ecore_Exe , usually for cleanup purposes .
*/
typedef void ( * Ecore_Exe_Cb ) ( void * data , const Ecore_Exe * exe ) ;
/**
* @ typedef Ecore_Event_Handler_Cb Ecore_Event_Handler_Cb
* A callback used by the main loop to handle events of a specified type .
*/
typedef Eina_Bool ( * Ecore_Event_Handler_Cb ) ( void * data , int type , void * event ) ;
/**
2010-11-12 05:28:19 -08:00
* @ typedef Ecore_Thread_Cb Ecore_Thread_Cb
* A callback used by Ecore_Thread helper .
2010-08-03 19:55:20 -07:00
*/
2010-11-12 05:28:19 -08:00
typedef void ( * Ecore_Thread_Cb ) ( void * data , Ecore_Thread * thread ) ;
2010-08-03 19:55:20 -07:00
/**
* @ typedef Ecore_Thread_Notify_Cb Ecore_Thread_Notify_Cb
2010-10-17 00:03:28 -07:00
* A callback used by the main loop to receive data sent by an @ ref Ecore_Thread_Group .
2010-08-03 19:55:20 -07:00
*/
2010-11-12 05:28:19 -08:00
typedef void ( * Ecore_Thread_Notify_Cb ) ( void * data , Ecore_Thread * thread , void * msg_data ) ;
2010-08-03 19:55:20 -07:00
/**
* @ typedef Ecore_Task_Cb Ecore_Task_Cb
2011-04-19 23:51:39 -07:00
* A callback run for a task ( timer , idler , poller , animator , etc )
2010-08-03 19:55:20 -07:00
*/
typedef Eina_Bool ( * Ecore_Task_Cb ) ( void * data ) ;
2011-04-19 23:51:39 -07:00
/**
* @ typedef Ecore_Timeline_Cb Ecore_Timeline_Cb
* A callback run for a task ( animators with runtimes )
*/
typedef Eina_Bool ( * Ecore_Timeline_Cb ) ( void * data , double pos ) ;
2010-08-03 19:55:20 -07:00
/**
* @ typedef Ecore_Cb Ecore_Cb
* A generic callback called as a hook when a certain point in execution is reached .
*/
typedef void ( * Ecore_Cb ) ( void * data ) ;
/**
* @ typedef Ecore_Fd_Cb Ecore_Fd_Cb
* A callback used by an @ ref Ecore_Fd_Handler .
*/
typedef Eina_Bool ( * Ecore_Fd_Cb ) ( void * data , Ecore_Fd_Handler * fd_handler ) ;
/**
* @ typedef Ecore_Fd_Prep_Cb Ecore_Fd_Prep_Cb
* A callback used by an @ ref Ecore_Fd_Handler .
*/
typedef void ( * Ecore_Fd_Prep_Cb ) ( void * data , Ecore_Fd_Handler * fd_handler ) ;
/**
2011-03-13 03:46:25 -07:00
* @ typedef Ecore_Win32_Handle_Cb Ecore_Win32_Handle_Cb
2010-08-03 19:55:20 -07:00
* A callback used by an @ ref Ecore_Win32_Handler .
*/
2011-03-13 03:46:25 -07:00
typedef Eina_Bool ( * Ecore_Win32_Handle_Cb ) ( void * data , Ecore_Win32_Handler * wh ) ;
2010-07-25 21:20:18 -07:00
2003-09-23 01:09:32 -07:00
2010-01-25 13:59:21 -08:00
typedef struct _Ecore_Job Ecore_Job ; /**< A job handle */
2003-09-23 01:09:32 -07:00
struct _Ecore_Event_Signal_User /** User signal event */
{
2010-09-29 23:09:20 -07:00
int number ; /**< The signal number. Either 1 or 2 */
void * ext_data ; /**< Extension data - not used */
2004-10-20 10:51:29 -07:00
2007-08-26 04:17:21 -07:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2004-10-20 10:51:29 -07:00
# endif
2003-09-23 01:09:32 -07:00
} ;
2007-08-26 04:17:21 -07:00
2003-09-23 01:09:32 -07:00
struct _Ecore_Event_Signal_Hup /** Hup signal event */
{
2010-09-29 23:09:20 -07:00
void * ext_data ; /**< Extension data - not used */
2004-10-20 10:51:29 -07:00
2007-08-26 04:17:21 -07:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2004-10-20 10:51:29 -07:00
# endif
2003-09-23 01:09:32 -07:00
} ;
2007-08-26 04:17:21 -07:00
2003-09-23 01:09:32 -07:00
struct _Ecore_Event_Signal_Exit /** Exit request event */
{
2011-01-26 10:38:13 -08:00
Eina_Bool interrupt : 1 ; /**< Set if the exit request was an interrupt signal*/
Eina_Bool quit : 1 ; /**< set if the exit request was a quit signal */
Eina_Bool terminate : 1 ; /**< Set if the exit request was a terminate singal */
2010-09-29 23:09:20 -07:00
void * ext_data ; /**< Extension data - not used */
2004-10-20 10:51:29 -07:00
2007-08-26 04:17:21 -07:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2004-10-20 10:51:29 -07:00
# endif
2003-09-23 01:09:32 -07:00
} ;
struct _Ecore_Event_Signal_Power /** Power event */
{
2010-09-29 23:09:20 -07:00
void * ext_data ; /**< Extension data - not used */
2004-10-20 10:51:29 -07:00
2007-08-26 04:17:21 -07:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2004-10-20 10:51:29 -07:00
# endif
2004-04-04 12:53:19 -07:00
} ;
struct _Ecore_Event_Signal_Realtime /** Realtime event */
{
2010-09-29 23:09:20 -07:00
int num ; /**< The realtime signal's number */
2004-10-20 10:51:29 -07:00
2007-08-26 04:17:21 -07:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2004-10-20 10:51:29 -07:00
# endif
2003-09-23 01:09:32 -07:00
} ;
2006-01-15 03:27:19 -08:00
struct _Ecore_Exe_Event_Add /** Process add event */
{
2010-09-29 23:09:20 -07:00
Ecore_Exe * exe ; /**< The handle to the added process */
void * ext_data ; /**< Extension data - not used */
2006-01-15 03:27:19 -08:00
} ;
struct _Ecore_Exe_Event_Del /** Process exit event */
{
2010-09-29 23:09:20 -07:00
pid_t pid ; /**< The process ID of the process that exited */
int exit_code ; /**< The exit code of the process */
Ecore_Exe * exe ; /**< The handle to the exited process, or NULL if not found */
int exit_signal ; /** < The signal that caused the process to exit */
2011-01-26 10:38:13 -08:00
Eina_Bool exited : 1 ; /** < set to 1 if the process exited of its own accord */
Eina_Bool signalled : 1 ; /** < set to 1 id the process exited due to uncaught signal */
2010-09-29 23:09:20 -07:00
void * ext_data ; /**< Extension data - not used */
2009-11-08 14:19:30 -08:00
# ifndef _WIN32
2010-09-29 23:09:20 -07:00
siginfo_t data ; /**< Signal info */
2009-11-08 14:19:30 -08:00
# endif
2006-01-15 03:27:19 -08:00
} ;
struct _Ecore_Exe_Event_Data_Line /**< Lines from a child process */
2005-12-15 17:11:24 -08:00
{
char * line ;
2010-09-29 23:09:20 -07:00
int size ;
2005-12-15 17:11:24 -08:00
} ;
2006-01-15 03:27:19 -08:00
struct _Ecore_Exe_Event_Data /** Data from a child process event */
2005-10-24 01:53:50 -07:00
{
2010-09-29 23:09:20 -07:00
Ecore_Exe * exe ; /**< The handle to the process */
void * data ; /**< the raw binary data from the child process that was received */
int size ; /**< the size of this data in bytes */
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 */
2005-10-24 01:53:50 -07:00
} ;
2007-08-26 04:17:21 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ defgroup Ecore_Init_Group Ecore initialisation and shutdown functions .
*/
2004-11-24 21:18:31 -08:00
EAPI int ecore_init ( void ) ;
EAPI int ecore_shutdown ( void ) ;
2007-08-26 04:17:21 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Application_Group Ecore Application functions
*
* @ {
*/
2004-11-24 21:18:31 -08:00
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 ) ;
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Event_Group Ecore Event functions
*
* @ {
*/
2010-08-03 19:55:20 -07:00
EAPI Ecore_Event_Handler * ecore_event_handler_add ( int type , Ecore_Event_Handler_Cb func , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_event_handler_del ( Ecore_Event_Handler * event_handler ) ;
2010-08-03 19:55:20 -07:00
EAPI Ecore_Event * ecore_event_add ( int type , void * ev , Ecore_End_Cb func_free , void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_event_del ( Ecore_Event * event ) ;
2010-11-04 13:51:17 -07:00
EAPI void * ecore_event_handler_data_get ( Ecore_Event_Handler * eh ) ;
2011-06-27 12:58:53 -07:00
EAPI void * ecore_event_handler_data_set ( Ecore_Event_Handler * eh , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI int ecore_event_type_new ( void ) ;
2010-08-03 19:55:20 -07:00
EAPI Ecore_Event_Filter * ecore_event_filter_add ( Ecore_Data_Cb func_start , Ecore_Filter_Cb func_filter , Ecore_End_Cb func_end , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_event_filter_del ( Ecore_Event_Filter * ef ) ;
EAPI int ecore_event_current_type_get ( void ) ;
EAPI void * ecore_event_current_event_get ( void ) ;
2007-08-26 04:17:21 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Exe_Group Process Spawning Functions
*
* @ {
*/
2007-08-26 04:17:21 -07:00
2008-11-01 18:29:08 -07:00
EAPI void ecore_exe_run_priority_set ( int pri ) ;
EAPI int ecore_exe_run_priority_get ( void ) ;
2005-09-28 06:09:09 -07:00
EAPI Ecore_Exe * ecore_exe_run ( const char * exe_cmd , const void * data ) ;
2005-10-24 01:53:50 -07:00
EAPI Ecore_Exe * ecore_exe_pipe_run ( const char * exe_cmd , Ecore_Exe_Flags flags , const void * data ) ;
2010-08-03 19:55:20 -07:00
EAPI void ecore_exe_callback_pre_free_set ( Ecore_Exe * exe , Ecore_Exe_Cb func ) ;
2010-01-05 21:16:59 -08:00
EAPI Eina_Bool ecore_exe_send ( Ecore_Exe * exe , const void * data , int size ) ;
2006-01-04 12:53:07 -08:00
EAPI void ecore_exe_close_stdin ( Ecore_Exe * exe ) ;
2006-01-16 05:21:52 -08:00
EAPI void ecore_exe_auto_limits_set ( Ecore_Exe * exe , int start_bytes , int end_bytes , int start_lines , int end_lines ) ;
EAPI Ecore_Exe_Event_Data * ecore_exe_event_data_get ( Ecore_Exe * exe , Ecore_Exe_Flags flags ) ;
EAPI void ecore_exe_event_data_free ( Ecore_Exe_Event_Data * data ) ;
2005-09-28 06:09:09 -07:00
EAPI void * ecore_exe_free ( Ecore_Exe * exe ) ;
2010-01-05 21:16:59 -08:00
EAPI pid_t ecore_exe_pid_get ( const Ecore_Exe * exe ) ;
2005-09-28 06:09:09 -07:00
EAPI void ecore_exe_tag_set ( Ecore_Exe * exe , const char * tag ) ;
2010-01-05 21:16:59 -08:00
EAPI const char * ecore_exe_tag_get ( const Ecore_Exe * exe ) ;
EAPI const char * ecore_exe_cmd_get ( const Ecore_Exe * exe ) ;
EAPI void * ecore_exe_data_get ( const Ecore_Exe * exe ) ;
2011-04-19 14:38:24 -07:00
EAPI void * ecore_exe_data_set ( Ecore_Exe * exe , void * data ) ;
2010-01-05 21:16:59 -08:00
EAPI Ecore_Exe_Flags ecore_exe_flags_get ( const Ecore_Exe * exe ) ;
2005-09-28 06:09:09 -07:00
EAPI void ecore_exe_pause ( Ecore_Exe * exe ) ;
EAPI void ecore_exe_continue ( Ecore_Exe * exe ) ;
2008-07-29 15:07:19 -07:00
EAPI void ecore_exe_interrupt ( Ecore_Exe * exe ) ;
EAPI void ecore_exe_quit ( Ecore_Exe * exe ) ;
2005-09-28 06:09:09 -07:00
EAPI void ecore_exe_terminate ( Ecore_Exe * exe ) ;
EAPI void ecore_exe_kill ( Ecore_Exe * exe ) ;
EAPI void ecore_exe_signal ( Ecore_Exe * exe , int num ) ;
EAPI void ecore_exe_hup ( Ecore_Exe * exe ) ;
2007-08-26 04:17:21 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Idle_Group Ecore Idle functions
*
* @ {
*/
2010-08-03 19:55:20 -07:00
EAPI Ecore_Idler * ecore_idler_add ( Ecore_Task_Cb func , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_idler_del ( Ecore_Idler * idler ) ;
2007-08-26 04:17:21 -07:00
2010-08-03 19:55:20 -07:00
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 ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_idle_enterer_del ( Ecore_Idle_Enterer * idle_enterer ) ;
2010-08-03 19:55:20 -07:00
EAPI Ecore_Idle_Exiter * ecore_idle_exiter_add ( Ecore_Task_Cb func , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_idle_exiter_del ( Ecore_Idle_Exiter * idle_exiter ) ;
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Main Loop_Group Ecore Main Loop functions
*
* @ {
*/
2004-11-24 21:18:31 -08:00
EAPI void ecore_main_loop_iterate ( void ) ;
2009-04-16 08:44:26 -07:00
2010-08-03 19:55:20 -07:00
EAPI void ecore_main_loop_select_func_set ( Ecore_Select_Function func ) ;
2011-01-22 02:11:14 -08:00
EAPI Ecore_Select_Function ecore_main_loop_select_func_get ( void ) ;
2009-04-16 08:44:26 -07:00
welcome glib main loop integration support.
that's it, it's here... tested and works fine, please try with your
favorite gmainloop dependent library and report problems. Suggestions:
* GConf to access Gnome and its applications settings.
* GtkSettings to access other properties of Gnome and its applications.
* GUPnP (okay, we have EUPnP, but they have more features so far)
* Rygel, based on GUPnP.
* Libsoup, SOAP and HTTP access, useful for web access and required
by other libraries.
* Mojito, by Moblin, access to various web2.0 services like flickr,
picasa, twitter...
And last but not least, this enables Flash plugin on WebKit-EFL and
may enable us to get Google Gadgets sooner (before someone writes a
proper EFL backend).
Support is auto-detected at compile time but can be disabled with
--disable-glib. Runtime support is not enabled by default (so
compiling with it will just link yet another library), one needs to
call ecore_main_loop_glib_integrate() to do so.
Thanks to INdT folks that provided the initial implementation. I
rewrote it to make it correct, but the idea was good.
SVN revision: 42825
2009-09-30 20:56:38 -07:00
EAPI Eina_Bool ecore_main_loop_glib_integrate ( void ) ;
2010-03-21 20:30:40 -07:00
EAPI void ecore_main_loop_glib_always_integrate_disable ( void ) ;
2004-11-24 21:18:31 -08:00
EAPI void ecore_main_loop_begin ( void ) ;
EAPI void ecore_main_loop_quit ( void ) ;
2010-08-03 19:55:20 -07:00
EAPI Ecore_Fd_Handler * ecore_main_fd_handler_add ( int fd , Ecore_Fd_Handler_Flags flags , Ecore_Fd_Cb func , const void * data ,
Ecore_Fd_Cb buf_func , const void * buf_data ) ;
EAPI void ecore_main_fd_handler_prepare_callback_set ( Ecore_Fd_Handler * fd_handler , Ecore_Fd_Prep_Cb func , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_main_fd_handler_del ( Ecore_Fd_Handler * fd_handler ) ;
EAPI int ecore_main_fd_handler_fd_get ( Ecore_Fd_Handler * fd_handler ) ;
2010-09-20 19:06:41 -07:00
EAPI Eina_Bool ecore_main_fd_handler_active_get ( Ecore_Fd_Handler * fd_handler , Ecore_Fd_Handler_Flags flags ) ;
2004-11-24 21:18:31 -08:00
EAPI void ecore_main_fd_handler_active_set ( Ecore_Fd_Handler * fd_handler , Ecore_Fd_Handler_Flags flags ) ;
2009-10-25 03:11:59 -07:00
2011-03-13 03:46:25 -07:00
EAPI Ecore_Win32_Handler * ecore_main_win32_handler_add ( void * h , Ecore_Win32_Handle_Cb func , const void * data ) ;
2009-11-23 15:09:48 -08:00
EAPI void * ecore_main_win32_handler_del ( Ecore_Win32_Handler * win32_handler ) ;
2007-08-26 04:17:21 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Pipe_Group Pipe wrapper
*
* @ {
*/
2010-08-03 19:55:20 -07:00
EAPI Ecore_Pipe * ecore_pipe_add ( Ecore_Pipe_Cb handler , const void * data ) ;
2008-11-02 21:42:27 -08:00
EAPI void * ecore_pipe_del ( Ecore_Pipe * p ) ;
2010-06-10 04:57:12 -07:00
EAPI Eina_Bool ecore_pipe_write ( Ecore_Pipe * p , const void * buffer , unsigned int nbytes ) ;
2009-04-23 00:08:50 -07:00
EAPI void ecore_pipe_write_close ( Ecore_Pipe * p ) ;
EAPI void ecore_pipe_read_close ( Ecore_Pipe * p ) ;
2011-05-31 01:05:16 -07:00
EAPI void ecore_pipe_thaw ( Ecore_Pipe * p ) ;
2011-05-30 09:52:19 -07:00
EAPI void ecore_pipe_freeze ( Ecore_Pipe * p ) ;
2011-06-09 07:54:24 -07:00
EAPI int ecore_pipe_wait ( Ecore_Pipe * p , int message_count , double wait ) ;
2008-11-02 21:42:27 -08:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
2010-07-30 01:52:18 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ defgroup Ecore_Thread_Group Ecore Thread functions
*
* @ {
*/
2010-07-30 01:52:18 -07:00
2010-11-12 05:28:19 -08:00
EAPI Ecore_Thread * ecore_thread_run ( Ecore_Thread_Cb func_blocking ,
Ecore_Thread_Cb func_end ,
Ecore_Thread_Cb func_cancel ,
2010-07-30 01:52:18 -07:00
const void * data ) ;
2010-11-12 05:28:19 -08:00
EAPI Ecore_Thread * ecore_thread_feedback_run ( Ecore_Thread_Cb func_heavy ,
2010-10-13 10:45:07 -07:00
Ecore_Thread_Notify_Cb func_notify ,
2010-11-12 05:28:19 -08:00
Ecore_Thread_Cb func_end ,
Ecore_Thread_Cb func_cancel ,
2010-09-29 23:09:20 -07:00
const void * data ,
Eina_Bool try_no_queue ) ;
2009-12-01 23:22:35 -08:00
EAPI Eina_Bool ecore_thread_cancel ( Ecore_Thread * thread ) ;
2010-06-30 06:25:28 -07:00
EAPI Eina_Bool ecore_thread_check ( Ecore_Thread * thread ) ;
2010-09-22 02:47:55 -07:00
EAPI Eina_Bool ecore_thread_feedback ( Ecore_Thread * thread , const void * msg_data ) ;
2011-03-16 06:16:14 -07:00
EAPI Eina_Bool ecore_thread_reschedule ( Ecore_Thread * thread ) ;
2010-07-20 02:40:18 -07:00
EAPI int ecore_thread_active_get ( void ) ;
EAPI int ecore_thread_pending_get ( void ) ;
2010-09-22 02:47:55 -07:00
EAPI int ecore_thread_pending_feedback_get ( void ) ;
2010-07-20 21:03:40 -07:00
EAPI int ecore_thread_pending_total_get ( void ) ;
2010-07-20 18:04:28 -07:00
EAPI int ecore_thread_max_get ( void ) ;
EAPI void ecore_thread_max_set ( int num ) ;
2010-07-20 19:12:10 -07:00
EAPI void ecore_thread_max_reset ( void ) ;
2010-07-21 00:09:51 -07:00
EAPI int ecore_thread_available_get ( void ) ;
2010-08-18 01:56:44 -07:00
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 ) ;
2010-10-17 00:03:28 -07:00
EAPI void * ecore_thread_local_data_find ( Ecore_Thread * thread , const char * key ) ;
2010-08-18 01:56:44 -07:00
EAPI Eina_Bool ecore_thread_local_data_del ( Ecore_Thread * thread , const char * key ) ;
2010-07-23 08:33:22 -07:00
2010-07-30 01:52:18 -07:00
EAPI Eina_Bool ecore_thread_global_data_add ( const char * key , void * value , Eina_Free_Cb cb , Eina_Bool direct ) ;
2010-07-30 08:56:18 -07:00
EAPI void * ecore_thread_global_data_set ( const char * key , void * value , Eina_Free_Cb cb ) ;
2010-10-17 00:03:28 -07:00
EAPI void * ecore_thread_global_data_find ( const char * key ) ;
2010-07-23 08:33:22 -07:00
EAPI Eina_Bool ecore_thread_global_data_del ( const char * key ) ;
2010-10-17 00:03:28 -07:00
EAPI void * ecore_thread_global_data_wait ( const char * key , double seconds ) ;
2010-07-30 01:52:18 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
2010-07-23 08:33:22 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ defgroup Ecore_Time_Group Ecore Time functions
*
* @ {
*/
2009-07-31 10:06:11 -07:00
2004-11-24 21:18:31 -08:00
EAPI double ecore_time_get ( void ) ;
2010-09-27 15:35:35 -07:00
EAPI double ecore_time_unix_get ( void ) ;
2008-11-01 18:29:08 -07:00
EAPI double ecore_loop_time_get ( void ) ;
2009-04-22 18:38:55 -07:00
2010-08-03 19:55:20 -07:00
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 ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_timer_del ( Ecore_Timer * timer ) ;
2005-02-22 04:39:50 -08:00
EAPI void ecore_timer_interval_set ( Ecore_Timer * timer , double in ) ;
2009-04-26 10:16:33 -07:00
EAPI double ecore_timer_interval_get ( Ecore_Timer * timer ) ;
2008-03-09 08:56:17 -07:00
EAPI void ecore_timer_freeze ( Ecore_Timer * timer ) ;
EAPI void ecore_timer_thaw ( Ecore_Timer * timer ) ;
2008-05-20 05:37:51 -07:00
EAPI void ecore_timer_delay ( Ecore_Timer * timer , double add ) ;
EAPI double ecore_timer_pending_get ( Ecore_Timer * timer ) ;
2008-11-13 12:42:01 -08:00
EAPI double ecore_timer_precision_get ( void ) ;
EAPI void ecore_timer_precision_set ( double precision ) ;
2011-05-17 10:32:32 -07:00
EAPI char * ecore_timer_dump ( void ) ;
2008-11-13 12:42:01 -08:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Animator_Group Ecore Animator functions
*
* @ {
*/
2010-08-03 19:55:20 -07:00
EAPI Ecore_Animator * ecore_animator_add ( Ecore_Task_Cb func , const void * data ) ;
2011-04-24 07:25:43 -07:00
EAPI Ecore_Animator * ecore_animator_timeline_add ( double runtime , Ecore_Timeline_Cb func , const void * data ) ;
2004-11-24 21:18:31 -08:00
EAPI void * ecore_animator_del ( Ecore_Animator * animator ) ;
2010-09-29 23:09:20 -07:00
EAPI void ecore_animator_freeze ( Ecore_Animator * animator ) ;
EAPI void ecore_animator_thaw ( Ecore_Animator * animator ) ;
2004-11-24 21:18:31 -08:00
EAPI void ecore_animator_frametime_set ( double frametime ) ;
EAPI double ecore_animator_frametime_get ( void ) ;
2011-04-19 23:51:39 -07:00
EAPI double ecore_animator_pos_map ( double pos , Ecore_Pos_Map map , double v1 , double v2 ) ;
2011-05-12 02:11:36 -07:00
EAPI void ecore_animator_source_set ( Ecore_Animator_Source source ) ;
EAPI Ecore_Animator_Source ecore_animator_source_get ( void ) ;
EAPI void ecore_animator_custom_source_tick_begin_callback_set ( Ecore_Cb func , const void * data ) ;
EAPI void ecore_animator_custom_source_tick_end_callback_set ( Ecore_Cb func , const void * data ) ;
EAPI void ecore_animator_custom_tick ( void ) ;
2011-04-19 23:51:39 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Poller_Group Ecore Poll functions
*
* @ {
*/
2008-01-10 23:33:57 -08:00
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 ) ;
2010-05-19 02:16:37 -07:00
EAPI Eina_Bool ecore_poller_poller_interval_set ( Ecore_Poller * poller , int interval ) ;
EAPI int ecore_poller_poller_interval_get ( Ecore_Poller * poller ) ;
2010-08-03 19:55:20 -07:00
EAPI Ecore_Poller * ecore_poller_add ( Ecore_Poller_Type type , int interval , Ecore_Task_Cb func , const void * data ) ;
2008-01-10 23:33:57 -08:00
EAPI void * ecore_poller_del ( Ecore_Poller * poller ) ;
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ defgroup Ecore_Job_Group Ecore Job functions
*
* @ {
*/
2010-08-03 19:55:20 -07:00
EAPI Ecore_Job * ecore_job_add ( Ecore_Cb func , const void * data ) ;
2010-01-25 13:59:21 -08:00
EAPI void * ecore_job_del ( Ecore_Job * job ) ;
2008-05-25 22:16:34 -07:00
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
/**
* @ }
*/
2003-09-23 01:09:32 -07:00
# ifdef __cplusplus
}
# endif
# endif