* @{
*/
-EAPI int
- ecore_init(void);
-EAPI int
- ecore_shutdown(void);
+EAPI int ecore_init(void);
+EAPI int ecore_shutdown(void);
/**
* @}
*/
typedef int (*Ecore_Select_Function)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
-EAPI void
-ecore_main_loop_iterate(void);
+EAPI void ecore_main_loop_iterate(void);
-EAPI void
- ecore_main_loop_select_func_set(Ecore_Select_Function func);
-EAPI Ecore_Select_Function
- ecore_main_loop_select_func_get(void);
+EAPI void ecore_main_loop_select_func_set(Ecore_Select_Function func);
+EAPI Ecore_Select_Function ecore_main_loop_select_func_get(void);
-EAPI Eina_Bool
- ecore_main_loop_glib_integrate(void);
-EAPI void
- ecore_main_loop_glib_always_integrate_disable(void);
+EAPI Eina_Bool ecore_main_loop_glib_integrate(void);
+EAPI void ecore_main_loop_glib_always_integrate_disable(void);
-EAPI void
- ecore_main_loop_begin(void);
-EAPI void
- ecore_main_loop_quit(void);
+EAPI void ecore_main_loop_begin(void);
+EAPI void ecore_main_loop_quit(void);
/**
* @typedef Ecore_Cb Ecore_Cb
* in the thread, it is owned by the main loop and your callback should take
* care of freeing it if necessary.
*/
-EAPI void
-ecore_main_loop_thread_safe_call_async(Ecore_Cb callback,
- void *data);
+EAPI void ecore_main_loop_thread_safe_call_async(Ecore_Cb callback, void *data);
/**
* @brief Call callback synchronously in the main loop.
* Remember this function will block until the callback is executed in the
* main loop. It can take time and you have no guaranty about the timeline.
*/
-EAPI void *
-ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback,
- void *data);
+EAPI void *ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback, void *data);
/**
* @brief This function suspend the main loop in a know state
* We still advise you, when possible, to use ecore_main_loop_thread_safe_call_async()
* as it will not block the thread nor the main loop.
*/
-EAPI int
-ecore_thread_main_loop_begin(void);
+EAPI int ecore_thread_main_loop_begin(void);
/**
* @brief Unlock the main loop.
* After a call to ecore_thread_main_loop_begin(), you need to absolutly
* call ecore_thread_main_loop_end(), or you application will stay frozen.
*/
-EAPI int
-ecore_thread_main_loop_end(void);
+EAPI int ecore_thread_main_loop_end(void);
/**
* @}
#endif
};
-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);
-EAPI void *
- ecore_event_del(Ecore_Event *event);
-EAPI void *
- ecore_event_handler_data_get(Ecore_Event_Handler *eh);
-EAPI void *
- ecore_event_handler_data_set(Ecore_Event_Handler *eh,
- const void *data);
-EAPI int
- ecore_event_type_new(void);
-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);
-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);
+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);
+EAPI void *ecore_event_del(Ecore_Event *event);
+EAPI void *ecore_event_handler_data_get(Ecore_Event_Handler *eh);
+EAPI void *ecore_event_handler_data_set(Ecore_Event_Handler *eh, const void *data);
+EAPI int ecore_event_type_new(void);
+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);
+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);
/**
* @}
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_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;
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 */
};
-EAPI void
- ecore_exe_run_priority_set(int pri);
-EAPI int
- ecore_exe_run_priority_get(void);
-EAPI Ecore_Exe *
- ecore_exe_run(const char *exe_cmd,
- const void *data);
-EAPI Ecore_Exe *
-ecore_exe_pipe_run(const char *exe_cmd,
- Ecore_Exe_Flags flags,
- const void *data);
-EAPI void
-ecore_exe_callback_pre_free_set(Ecore_Exe *exe,
- Ecore_Exe_Cb func);
-EAPI Eina_Bool
-ecore_exe_send(Ecore_Exe *exe,
- const void *data,
- int size);
-EAPI void
- ecore_exe_close_stdin(Ecore_Exe *exe);
-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);
-EAPI void *
- ecore_exe_free(Ecore_Exe *exe);
-EAPI pid_t
- ecore_exe_pid_get(const Ecore_Exe *exe);
-EAPI void
- ecore_exe_tag_set(Ecore_Exe *exe,
- const char *tag);
-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);
-EAPI void *
- ecore_exe_data_set(Ecore_Exe *exe,
- void *data);
-EAPI Ecore_Exe_Flags
- ecore_exe_flags_get(const Ecore_Exe *exe);
-EAPI void
- ecore_exe_pause(Ecore_Exe *exe);
-EAPI void
- ecore_exe_continue(Ecore_Exe *exe);
-EAPI void
- ecore_exe_interrupt(Ecore_Exe *exe);
-EAPI void
- ecore_exe_quit(Ecore_Exe *exe);
-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);
+EAPI void ecore_exe_run_priority_set(int pri);
+EAPI int ecore_exe_run_priority_get(void);
+EAPI Ecore_Exe *ecore_exe_run(const char *exe_cmd, const void *data);
+EAPI Ecore_Exe *ecore_exe_pipe_run(const char *exe_cmd, Ecore_Exe_Flags flags, const void *data);
+EAPI void ecore_exe_callback_pre_free_set(Ecore_Exe *exe, Ecore_Exe_Cb func);
+EAPI Eina_Bool ecore_exe_send(Ecore_Exe *exe, const void *data, int size);
+EAPI void ecore_exe_close_stdin(Ecore_Exe *exe);
+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);
+EAPI void *ecore_exe_free(Ecore_Exe *exe);
+EAPI pid_t ecore_exe_pid_get(const Ecore_Exe *exe);
+EAPI void ecore_exe_tag_set(Ecore_Exe *exe, const char *tag);
+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);
+EAPI void *ecore_exe_data_set(Ecore_Exe *exe, void *data);
+EAPI Ecore_Exe_Flags ecore_exe_flags_get(const Ecore_Exe *exe);
+EAPI void ecore_exe_pause(Ecore_Exe *exe);
+EAPI void ecore_exe_continue(Ecore_Exe *exe);
+EAPI void ecore_exe_interrupt(Ecore_Exe *exe);
+EAPI void ecore_exe_quit(Ecore_Exe *exe);
+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);
/**
* @}
* for data available for reading, for the availability to write
* without blocking, and for errors on the file descriptor.
*
- * ecore_main_fd_handler_add() is used to setup a handler for a
+ *ecore_main_fd_handler_add() is used to setup a handler for a
* given file descriptor. This file descriptor can be the standard
* input, a network socket, a stream received through some driver
* of a hardware decoder, etc. Thus it can contain errors, like a
*/
typedef Eina_Bool (*Ecore_Win32_Handle_Cb)(void *data, Ecore_Win32_Handler *wh);
-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);
-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);
-EAPI Eina_Bool
- ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler,
- Ecore_Fd_Handler_Flags flags);
-EAPI void
-ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler,
- Ecore_Fd_Handler_Flags flags);
-
-EAPI Ecore_Win32_Handler *
-ecore_main_win32_handler_add(void *h,
- Ecore_Win32_Handle_Cb func,
- const void *data);
-EAPI void *
-ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler);
+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);
+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);
+EAPI Eina_Bool ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags);
+EAPI void ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags);
+
+EAPI Ecore_Win32_Handler *ecore_main_win32_handler_add(void *h, Ecore_Win32_Handle_Cb func, const void *data);
+EAPI void *ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler);
/**
* @}
typedef struct _Ecore_Poller Ecore_Poller; /**< A handle for pollers */
-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);
-EAPI int
- ecore_poller_poller_interval_get(Ecore_Poller *poller);
-EAPI Ecore_Poller *
- ecore_poller_add(Ecore_Poller_Type type,
- int interval,
- Ecore_Task_Cb func,
- const void *data);
+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);
+EAPI int ecore_poller_poller_interval_get(Ecore_Poller *poller);
+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);
/**
* ... do some more animating ...
* }
* ...
- * ecore_animator_timeline_add(2, _do_animation, my_evas_object);
+ *ecore_animator_timeline_add(2, _do_animation, my_evas_object);
* @endcode
* In the sample above we create an animation to move
* @c my_evas_object from position (0,0) to (100,100) in 2 seconds.
*
* If your animation will run for an unspecified amount of time you
* can use ecore_animator_add(), which is like using
- * ecore_timer_add() with the interval being the
+ *ecore_timer_add() with the interval being the
* @ref ecore_animator_frametime_set "framerate". Note that this has
* tangible benefits to creating a timer for each animation in terms
* of performance.
* @see ecore_animator_timeline_add()
* @see ecore_animator_frametime_set()
*/
-EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func,
- const void *data);
+EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
/**
* @brief Add a animator that runs for a limited time
*
* @see ecore_animator_pos_map()
* @since 1.1.0
*/
-EAPI Ecore_Animator *
-ecore_animator_timeline_add(double runtime,
- Ecore_Timeline_Cb func,
- const void *data);
+EAPI Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_Cb func, const void *data);
/**
* @brief Delete the specified animator from the animator list.
*
* is invalid and should not be used again. It will not get called again after
* deletion.
*/
-EAPI void *
-ecore_animator_del(Ecore_Animator *animator);
+EAPI void *ecore_animator_del(Ecore_Animator *animator);
/**
* @brief Suspend the specified animator.
*
*
* @warning Freezing an animator doesn't freeze accounting of how long that
* animator has been running. Therefore if the animator was created with
- * ecore_animator_timeline_add() the @p pos argument given to the callback
+ *ecore_animator_timeline_add() the @p pos argument given to the callback
* will increase as if the animator hadn't been frozen and the animator may
* have it's execution halted if @p runtime elapsed.
*/
-EAPI void
-ecore_animator_freeze(Ecore_Animator *animator);
+EAPI void ecore_animator_freeze(Ecore_Animator *animator);
/**
* @brief Restore execution of the specified animator.
*
* The specified @p animator will be put back in the set of animators that are
* executed during main loop.
*/
-EAPI void
-ecore_animator_thaw(Ecore_Animator *animator);
+EAPI void ecore_animator_thaw(Ecore_Animator *animator);
/**
* @brief Set the animator call interval in seconds.
*
*
* @note The default @p frametime value is 1/30th of a second.
*/
-EAPI void
-ecore_animator_frametime_set(double frametime);
+EAPI void ecore_animator_frametime_set(double frametime);
/**
* @brief Get the animator call interval in seconds.
*
*
* @see ecore_animator_frametime_set()
*/
-EAPI double
-ecore_animator_frametime_get(void);
+EAPI double ecore_animator_frametime_get(void);
/**
* @brief Maps an input position from 0.0 to 1.0 along a timeline to a
* position in a different curve.
*
* @since 1.1.0
*/
-EAPI double
-ecore_animator_pos_map(double pos,
- Ecore_Pos_Map map,
- double v1,
- double v2);
+EAPI double ecore_animator_pos_map(double pos, Ecore_Pos_Map map, double v1, double v2);
/**
* @brief Set the source of animator ticks for the mainloop
*
* ECORE_ANIMATOR_SOURCE_CUSTOM and then drive it yourself based on some input
* tick source (like another application via ipc, some vertical blanking
* interrupt interrupt etc.) using
- * ecore_animator_custom_source_tick_begin_callback_set() and
- * ecore_animator_custom_source_tick_end_callback_set() to set the functions
+ *ecore_animator_custom_source_tick_begin_callback_set() and
+ *ecore_animator_custom_source_tick_end_callback_set() to set the functions
* that will be called to start and stop the ticking source, which when it
* gets a "tick" should call ecore_animator_custom_tick() to make the "tick" over 1
* frame.
*/
-EAPI void
-ecore_animator_source_set(Ecore_Animator_Source source);
+EAPI void ecore_animator_source_set(Ecore_Animator_Source source);
/**
* @brief Get the animator source currently set.
*
*
* @see ecore_animator_source_set()
*/
-EAPI Ecore_Animator_Source
-ecore_animator_source_get(void);
+EAPI Ecore_Animator_Source ecore_animator_source_get(void);
/**
* @brief Set the function that begins a custom animator tick source
*
* The Ecore Animator infrastructure handles tracking if animators are needed
* or not and which ones need to be called and when, but when the tick source
* is custom, you have to provide a tick source by calling
- * ecore_animator_custom_tick() to indicate a frame tick happened. In order
+ *ecore_animator_custom_tick() to indicate a frame tick happened. In order
* to allow the source of ticks to be dynamically enabled or disabled as
* needed, the @p func when set is called to enable the tick source to
* produce tick events that call ecore_animator_custom_tick(). If @p func
* @see ecore_animator_custom_source_tick_end_callback_set()
* @see ecore_animator_custom_tick()
*/
-EAPI void
-ecore_animator_custom_source_tick_begin_callback_set(Ecore_Cb func,
- const void *data);
+EAPI void ecore_animator_custom_source_tick_begin_callback_set(Ecore_Cb func, const void *data);
/**
* @brief Set the function that ends a custom animator tick source
*
* @param data The data passed to the tick end function as its parameter
*
* This function is a matching pair to the function set by
- * ecore_animator_custom_source_tick_begin_callback_set() and is called
+ *ecore_animator_custom_source_tick_begin_callback_set() and is called
* when ticking is to stop. If @p func is NULL then no function will be
* called to stop ticking. For more information please see
- * ecore_animator_custom_source_tick_begin_callback_set().
+ *ecore_animator_custom_source_tick_begin_callback_set().
*
* @see ecore_animator_source_set()
* @see ecore_animator_custom_source_tick_begin_callback_set()
* @see ecore_animator_custom_tick()
*/
-EAPI void
-ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb func,
- const void *data);
+EAPI void ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb func, const void *data);
/**
* @brief Trigger a custom animator tick
*
* @see ecore_animator_custom_source_tick_begin_callback_set
* @see ecore_animator_custom_source_tick_end_callback_set()()
*/
-EAPI void
-ecore_animator_custom_tick(void);
+EAPI void ecore_animator_custom_tick(void);
/**
* @}
typedef struct _Ecore_Timer Ecore_Timer; /**< A handle for timers */
-EAPI double
- ecore_time_get(void);
-EAPI double
- ecore_time_unix_get(void);
-EAPI double
- ecore_loop_time_get(void);
-
-EAPI Ecore_Timer *
-ecore_timer_add(double in,
- Ecore_Task_Cb func,
- const void *data);
-EAPI Ecore_Timer *
-ecore_timer_loop_add(double in,
- Ecore_Task_Cb func,
- const void *data);
-EAPI void *
- ecore_timer_del(Ecore_Timer *timer);
-EAPI void
- ecore_timer_interval_set(Ecore_Timer *timer,
- double in);
-EAPI double
- ecore_timer_interval_get(Ecore_Timer *timer);
-EAPI void
- ecore_timer_freeze(Ecore_Timer *timer);
-EAPI void
- ecore_timer_thaw(Ecore_Timer *timer);
-EAPI void
- ecore_timer_delay(Ecore_Timer *timer,
- double add);
-EAPI double
- ecore_timer_pending_get(Ecore_Timer *timer);
-EAPI double
- ecore_timer_precision_get(void);
-EAPI void
- ecore_timer_precision_set(double precision);
-EAPI char *
- ecore_timer_dump(void);
+EAPI double ecore_time_get(void);
+EAPI double ecore_time_unix_get(void);
+EAPI double ecore_loop_time_get(void);
+
+EAPI Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *data);
+EAPI Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data);
+EAPI void *ecore_timer_del(Ecore_Timer *timer);
+EAPI void ecore_timer_interval_set(Ecore_Timer *timer, double in);
+EAPI double ecore_timer_interval_get(Ecore_Timer *timer);
+EAPI void ecore_timer_freeze(Ecore_Timer *timer);
+EAPI void ecore_timer_thaw(Ecore_Timer *timer);
+EAPI void ecore_timer_delay(Ecore_Timer *timer, double add);
+EAPI double ecore_timer_pending_get(Ecore_Timer *timer);
+EAPI double ecore_timer_precision_get(void);
+EAPI void ecore_timer_precision_set(double precision);
+EAPI char *ecore_timer_dump(void);
/**
* @}
*
* Idlers are useful for progressively prossessing data without blocking.
*/
-EAPI Ecore_Idler *
-ecore_idler_add(Ecore_Task_Cb func,
- const void *data);
+EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
/**
* Delete an idler callback from the list to be executed.
* @return The data pointer passed to the idler callback on success. NULL
* otherwise.
*/
-EAPI void *
-ecore_idler_del(Ecore_Idler *idler);
+EAPI void *ecore_idler_del(Ecore_Idler *idler);
-EAPI Ecore_Idle_Enterer *
-ecore_idle_enterer_add(Ecore_Task_Cb func,
- const void *data);
-EAPI Ecore_Idle_Enterer *
-ecore_idle_enterer_before_add(Ecore_Task_Cb func,
- const void *data);
-EAPI void *
-ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
+EAPI Ecore_Idle_Enterer *ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data);
+EAPI Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data);
+EAPI void *ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
-EAPI Ecore_Idle_Exiter *
-ecore_idle_exiter_add(Ecore_Task_Cb func,
- const void *data);
-EAPI void *
-ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
+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);
/**
* @}
*
* The worker function, that's the one running in the thread, also receives
* an ::Ecore_Thread handler that can be used with ecore_thread_cancel() and
- * ecore_thread_check(), sharing the flag with the main loop. But this
+ *ecore_thread_check(), sharing the flag with the main loop. But this
* handler is also associated with the thread where the function is running.
* This has strong implications when working with thread local data.
*
* so here it's safe to use anything from the EFL freely.
*
* The thread can also be cancelled before its completion calling
- * ecore_thread_cancel(), either from the main thread or @p func_blocking.
+ *ecore_thread_cancel(), either from the main thread or @p func_blocking.
* In this case, @p func_cancel will be called, also from the main thread
* to inform of this happening. If the thread could not be created, this
* function will be called and it's @c thread parameter will be NULL. It's
* @see ecore_thread_reschedule()
* @see ecore_thread_max_set()
*/
-EAPI Ecore_Thread *
-ecore_thread_run(Ecore_Thread_Cb func_blocking,
- Ecore_Thread_Cb func_end,
- Ecore_Thread_Cb func_cancel,
- const void *data);
+EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Cb func_blocking, Ecore_Thread_Cb func_end, Ecore_Thread_Cb func_cancel, const void *data);
/**
* Launch a thread to run a task than can talk back to the main thread
*
* @see ecore_thread_reschedule()
* @see ecore_thread_max_set()
*/
-EAPI Ecore_Thread *
-ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy,
- Ecore_Thread_Notify_Cb func_notify,
- Ecore_Thread_Cb func_end,
- Ecore_Thread_Cb func_cancel,
- const void *data,
- Eina_Bool try_no_queue);
+EAPI Ecore_Thread *ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy, Ecore_Thread_Notify_Cb func_notify,
+ Ecore_Thread_Cb func_end, Ecore_Thread_Cb func_cancel,
+ const void *data, Eina_Bool try_no_queue);
/**
* Cancel a running thread.
*
* @li The function ends and returns normally. If it hadn't been cancelled,
* @c func_end would be called here, but instead @c func_cancel will happen.
* @li The function returns after requesting to be rescheduled with
- * ecore_thread_reschedule().
+ *ecore_thread_reschedule().
* @li The function is prepared to leave early by checking if
- * ecore_thread_check() returns EINA_TRUE.
+ *ecore_thread_check() returns EINA_TRUE.
*
* The user function can cancel itself by calling ecore_thread_cancel(), but
* it should always use the ::Ecore_Thread handle passed to it and never
*
* @see ecore_thread_check()
*/
-EAPI Eina_Bool
-ecore_thread_cancel(Ecore_Thread *thread);
+EAPI Eina_Bool ecore_thread_cancel(Ecore_Thread *thread);
/**
* Checks if a thread is pending cancellation
*
*
* @see ecore_thread_cancel()
*/
-EAPI Eina_Bool
-ecore_thread_check(Ecore_Thread *thread);
+EAPI Eina_Bool ecore_thread_check(Ecore_Thread *thread);
/**
* Sends data from the worker thread to the main loop
*
*
* @see ecore_thread_feedback_run()
*/
-EAPI Eina_Bool
-ecore_thread_feedback(Ecore_Thread *thread,
- const void *msg_data);
+EAPI Eina_Bool ecore_thread_feedback(Ecore_Thread *thread, const void *msg_data);
/**
* Asks for the function in the thread to be called again at a later time
*
* Similarly, if the @p thread is cancelled, the reschedule will not take
* effect.
*/
-EAPI Eina_Bool
-ecore_thread_reschedule(Ecore_Thread *thread);
+EAPI Eina_Bool ecore_thread_reschedule(Ecore_Thread *thread);
/**
* Gets the number of active threads running jobs
*
* in the return of this function unless the thread creation fails and it
* falls back to using one from the pool.
*/
-EAPI int
-ecore_thread_active_get(void);
+EAPI int ecore_thread_active_get(void);
/**
* Gets the number of short jobs waiting for a thread to run
*
* This returns the number of tasks started with ecore_thread_run() that are
* pending, waiting for a thread to become available to run them.
*/
-EAPI int
-ecore_thread_pending_get(void);
+EAPI int ecore_thread_pending_get(void);
/**
* Gets the number of feedback jobs waiting for a thread to run
*
* This returns the number of tasks started with ecore_thread_feedback_run()
* that are pending, waiting for a thread to become available to run them.
*/
-EAPI int
-ecore_thread_pending_feedback_get(void);
+EAPI int ecore_thread_pending_feedback_get(void);
/**
* Gets the total number of pending jobs
*
* @return Number of pending threads running jobs
*
* Same as the sum of ecore_thread_pending_get() and
- * ecore_thread_pending_feedback_get().
+ *ecore_thread_pending_feedback_get().
*/
-EAPI int
-ecore_thread_pending_total_get(void);
+EAPI int ecore_thread_pending_total_get(void);
/**
* Gets the maximum number of threads that can run simultaneously
*
*
* This returns the maximum number of Ecore_Thread's that may be running at
* the same time. If this number is reached, new jobs started by either
- * ecore_thread_run() or ecore_thread_feedback_run() will be added to the
+ *ecore_thread_run() or ecore_thread_feedback_run() will be added to the
* respective pending queue until one of the running threads finishes its
* task and becomes available to run a new one.
*
* @see ecore_thread_max_set()
* @see ecore_thread_max_reset()
*/
-EAPI int
-ecore_thread_max_get(void);
+EAPI int ecore_thread_max_get(void);
/**
* Sets the maximum number of threads allowed to run simultaneously
*
* @see ecore_thread_max_get()
* @see ecore_thread_max_reset()
*/
-EAPI void
-ecore_thread_max_set(int num);
+EAPI void ecore_thread_max_set(int num);
/**
* Resets the maximum number of concurrently running threads to the default
*
* @see ecore_thread_max_get()
* @see ecore_thread_max_set()
*/
-EAPI void
-ecore_thread_max_reset(void);
+EAPI void ecore_thread_max_reset(void);
/**
* Gets the number of threads available for running tasks
*
* changed the maximum number of running threads while other tasks are
* running.
*/
-EAPI int
-ecore_thread_available_get(void);
+EAPI int ecore_thread_available_get(void);
/**
* Adds some data to a hash local to the thread
*
* because @p thread was terminated and the hash destroyed. This parameter
* may be NULL, in which case @p value needs to be manually freed after
* removing it from the hash with either ecore_thread_local_data_del() or
- * ecore_thread_local_data_set(), but it's very unlikely that this is what
+ *ecore_thread_local_data_set(), but it's very unlikely that this is what
* you want.
*
* This function, and all of the others in the @c ecore_thread_local_data
* @see ecore_thread_local_data_find()
* @see ecore_thread_local_data_del()
*/
-EAPI Eina_Bool
-ecore_thread_local_data_add(Ecore_Thread *thread,
- const char *key,
- void *value,
- Eina_Free_Cb cb,
- Eina_Bool direct);
+EAPI Eina_Bool ecore_thread_local_data_add(Ecore_Thread *thread, const char *key, void *value,
+ Eina_Free_Cb cb, Eina_Bool direct);
/**
* Sets some data in the hash local to the given thread
*
* @see ecore_thread_local_data_del()
* @see ecore_thread_local_data_find()
*/
-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_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
/**
* Gets data stored in the hash local to the given thread
*
* @see ecore_thread_local_data_add()
* @see ecore_thread_local_data_wait()
*/
-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);
/**
* Deletes from the thread's hash the data corresponding to the given key
*
*
* @see ecore_thread_local_data_add()
*/
-EAPI Eina_Bool
-ecore_thread_local_data_del(Ecore_Thread *thread,
- const char *key);
+EAPI Eina_Bool ecore_thread_local_data_del(Ecore_Thread *thread, const char *key);
/**
* Adds some data to a hash shared by all threads
* because Ecore Thread was shut down and the hash destroyed. This parameter
* may be NULL, in which case @p value needs to be manually freed after
* removing it from the hash with either ecore_thread_global_data_del() or
- * ecore_thread_global_data_set().
+ *ecore_thread_global_data_set().
*
* Manually freeing any data that was added to the hash with a @p cb function
* is likely to produce a segmentation fault, or any other strange
* @see ecore_thread_global_data_set()
* @see ecore_thread_global_data_find()
*/
-EAPI Eina_Bool
-ecore_thread_global_data_add(const char *key,
- void *value,
- Eina_Free_Cb cb,
- Eina_Bool direct);
+EAPI Eina_Bool ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
/**
* Sets some data in the hash shared by all threads
*
* @see ecore_thread_global_data_del()
* @see ecore_thread_global_data_find()
*/
-EAPI void *
-ecore_thread_global_data_set(const char *key,
- void *value,
- Eina_Free_Cb cb);
+EAPI void *ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb);
/**
* Gets data stored in the hash shared by all threads
*
* @see ecore_thread_global_data_add()
* @see ecore_thread_global_data_wait()
*/
-EAPI void *
-ecore_thread_global_data_find(const char *key);
+EAPI void *ecore_thread_global_data_find(const char *key);
/**
* Deletes from the shared hash the data corresponding to the given key
*
*
* @see ecore_thread_global_data_add()
*/
-EAPI Eina_Bool
-ecore_thread_global_data_del(const char *key);
+EAPI Eina_Bool ecore_thread_global_data_del(const char *key);
/**
* Gets data stored in the shared hash, or wait for it if it doesn't exist
*
* If there's nothing in the hash under the given @p key, the function
* will block and wait up to @p seconds seconds for some other thread to
* add it with either ecore_thread_global_data_add() or
- * ecore_thread_global_data_set(). If after waiting there's still no data
+ *ecore_thread_global_data_set(). If after waiting there's still no data
* to get, NULL will be returned.
*
* If @p seconds is 0, then no waiting will happen and this function works
* @see ecore_thread_global_data_add()
* @see ecore_thread_global_data_find()
*/
-EAPI void *
-ecore_thread_global_data_wait(const char *key,
- double seconds);
+EAPI void *ecore_thread_global_data_wait(const char *key, double seconds);
/**
* @}
*/
typedef void (*Ecore_Pipe_Cb)(void *data, void *buffer, unsigned int nbyte);
-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);
-EAPI void
- ecore_pipe_thaw(Ecore_Pipe *p);
-EAPI void
- ecore_pipe_freeze(Ecore_Pipe *p);
-EAPI int
- ecore_pipe_wait(Ecore_Pipe *p,
- int message_count,
- double wait);
+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);
+EAPI void ecore_pipe_thaw(Ecore_Pipe *p);
+EAPI void ecore_pipe_freeze(Ecore_Pipe *p);
+EAPI int ecore_pipe_wait(Ecore_Pipe *p, int message_count, double wait);
/**
* @}
typedef struct _Ecore_Job Ecore_Job; /**< A job handle */
-EAPI Ecore_Job *
-ecore_job_add(Ecore_Cb func,
- const void *data);
-EAPI void *
-ecore_job_del(Ecore_Job *job);
+EAPI Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
+EAPI void *ecore_job_del(Ecore_Job *job);
/**
* @}
* @{
*/
-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);
+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);
/**
* @}
* @{
*/
-EAPI void
- ecore_throttle_adjust(double amount);
-EAPI double
- ecore_throttle_get(void);
+EAPI void ecore_throttle_adjust(double amount);
+EAPI double ecore_throttle_get(void);
/**
* @}
projects / profile / ivi / ecore.git / commitdiff