2009-01-31 10:33:39 -08:00
# ifdef HAVE_CONFIG_H
# include <config.h>
# endif
# include <stdlib.h>
2012-11-18 22:26:48 -08:00
# include <Eo.h>
2003-09-23 01:09:32 -07:00
# include "Ecore.h"
2009-12-22 13:15:12 -08:00
# include "ecore_private.h"
2003-09-23 01:09:32 -07:00
2012-10-10 01:19:58 -07:00
# define MY_CLASS ECORE_IDLE_ENTERER_CLASS
# define MY_CLASS_NAME "ecore_idle_enterer"
EAPI Eo_Op ECORE_IDLE_ENTERER_BASE_ID = EO_NOOP ;
struct _Ecore_Idle_Enterer_Private_Data
2011-12-11 00:29:35 -08:00
{
EINA_INLIST ;
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer * obj ;
Ecore_Task_Cb func ;
void * data ;
int references ;
Eina_Bool delete_me : 1 ;
2011-12-11 00:29:35 -08:00
} ;
2012-10-10 01:19:58 -07:00
typedef struct _Ecore_Idle_Enterer_Private_Data Ecore_Idle_Enterer_Private_Data ;
2011-12-11 00:29:35 -08:00
2012-10-10 01:19:58 -07:00
static Ecore_Idle_Enterer_Private_Data * idle_enterers = NULL ;
static Ecore_Idle_Enterer_Private_Data * idle_enterer_current = NULL ;
2011-10-20 22:40:39 -07:00
static int idle_enterers_delete_me = 0 ;
2003-09-23 01:09:32 -07:00
2011-07-28 05:01:16 -07:00
static void *
_ecore_idle_enterer_del ( Ecore_Idle_Enterer * idle_enterer ) ;
2010-10-17 00:03:28 -07:00
/**
2011-08-10 12:14:48 -07:00
* @ addtogroup Ecore_Idle_Group
2010-10-17 00:03:28 -07:00
*
* @ {
*/
2012-10-10 01:19:58 -07:00
static Eina_Bool
_ecore_idle_enterer_add ( Ecore_Idle_Enterer * obj ,
Ecore_Idle_Enterer_Private_Data * ie ,
Ecore_Task_Cb func ,
const void * data )
{
if ( EINA_UNLIKELY ( ! eina_main_loop_is ( ) ) )
{
eo_error_set ( obj ) ;
2012-10-10 18:29:56 -07:00
EINA_MAIN_LOOP_CHECK_RETURN_VAL ( EINA_FALSE ) ;
2012-10-10 01:19:58 -07:00
}
ie - > obj = obj ;
eo_do_super ( obj , eo_constructor ( ) ) ;
eo_manual_free_set ( obj , EINA_TRUE ) ;
if ( ! func )
{
eo_error_set ( obj ) ;
ERR ( " callback function must be set up for an object of class: '%s' " , MY_CLASS_NAME ) ;
return EINA_FALSE ;
}
ie - > func = func ;
ie - > data = ( void * ) data ;
return EINA_TRUE ;
}
2003-09-23 01:09:32 -07:00
/**
* Add an idle enterer handler .
2004-05-07 21:44:04 -07:00
* @ 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 .
2011-06-22 11:29:38 -07:00
* @ note The function func will be called every time the main loop is entering
* idle state , as long as it returns 1 ( or ECORE_CALLBACK_RENEW ) . A return of 0
* ( or ECORE_CALLBACK_CANCEL ) deletes the idle enterer .
2003-09-23 01:09:32 -07:00
*/
2006-01-06 09:58:12 -08:00
EAPI Ecore_Idle_Enterer *
2011-10-20 22:40:39 -07:00
ecore_idle_enterer_add ( Ecore_Task_Cb func ,
const void * data )
2003-09-23 01:09:32 -07:00
{
2011-07-28 05:01:16 -07:00
Ecore_Idle_Enterer * ie = NULL ;
2012-10-10 01:19:58 -07:00
ie = eo_add_custom ( MY_CLASS , _ecore_parent , ecore_idle_enterer_after_constructor ( func , data ) ) ;
eo_unref ( ie ) ;
return ie ;
}
static void
_idle_enterer_after_constructor ( Eo * obj , void * _pd , va_list * list )
{
Ecore_Task_Cb func = va_arg ( * list , Ecore_Task_Cb ) ;
const void * data = va_arg ( * list , const void * ) ;
2003-09-23 01:09:32 -07:00
2011-07-28 05:01:16 -07:00
_ecore_lock ( ) ;
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * ie = _pd ;
if ( ! _ecore_idle_enterer_add ( obj , ie , func , data ) ) goto unlock ;
idle_enterers = ( Ecore_Idle_Enterer_Private_Data * ) eina_inlist_append ( EINA_INLIST_GET ( idle_enterers ) , EINA_INLIST_GET ( ie ) ) ;
2011-07-05 04:13:29 -07:00
2011-07-28 05:01:16 -07:00
unlock :
_ecore_unlock ( ) ;
2003-09-23 01:09:32 -07:00
}
2008-01-10 23:33:57 -08:00
/**
* Add an idle enterer handler at the start of the list so it gets called earlier than others .
* @ 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 .
2011-06-22 11:29:38 -07:00
* @ note The function func will be called every time the main loop is entering
* idle state , as long as it returns 1 ( or ECORE_CALLBACK_RENEW ) . A return of 0
* ( or ECORE_CALLBACK_CANCEL ) deletes the idle enterer .
2008-01-10 23:33:57 -08:00
*/
EAPI Ecore_Idle_Enterer *
2011-10-20 22:40:39 -07:00
ecore_idle_enterer_before_add ( Ecore_Task_Cb func ,
const void * data )
2008-01-10 23:33:57 -08:00
{
2011-07-28 05:01:16 -07:00
Ecore_Idle_Enterer * ie = NULL ;
2012-10-10 01:19:58 -07:00
ie = eo_add_custom ( MY_CLASS , _ecore_parent , ecore_idle_enterer_before_constructor ( func , data ) ) ;
eo_unref ( ie ) ;
return ie ;
}
static void
_idle_enterer_before_constructor ( Eo * obj , void * _pd , va_list * list )
{
Ecore_Task_Cb func = va_arg ( * list , Ecore_Task_Cb ) ;
const void * data = va_arg ( * list , const void * ) ;
2008-01-10 23:33:57 -08:00
2011-07-28 05:01:16 -07:00
_ecore_lock ( ) ;
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * ie = _pd ;
if ( ! _ecore_idle_enterer_add ( obj , ie , func , data ) ) goto unlock ;
idle_enterers = ( Ecore_Idle_Enterer_Private_Data * ) eina_inlist_prepend ( EINA_INLIST_GET ( idle_enterers ) , EINA_INLIST_GET ( ie ) ) ;
2011-07-05 04:13:29 -07:00
2011-07-28 05:01:16 -07:00
unlock :
_ecore_unlock ( ) ;
2012-10-10 01:19:58 -07:00
}
static void
_constructor ( Eo * obj , void * _pd EINA_UNUSED , va_list * list EINA_UNUSED )
{
eo_error_set ( obj ) ;
ERR ( " only custom constructor can be used with '%s' class " , MY_CLASS_NAME ) ;
2008-01-10 23:33:57 -08:00
}
2003-09-23 01:09:32 -07:00
/**
2004-05-07 21:44:04 -07:00
* Delete an idle enterer callback .
* @ param idle_enterer The idle enterer to delete
* @ return The data pointer passed to the idler enterer callback on success .
* NULL otherwise .
2003-09-23 01:09:32 -07:00
*/
2006-01-06 09:58:12 -08:00
EAPI void *
2003-09-23 01:09:32 -07:00
ecore_idle_enterer_del ( Ecore_Idle_Enterer * idle_enterer )
{
2012-10-10 01:19:58 -07:00
void * data = NULL ;
2011-07-05 04:13:29 -07:00
2012-03-29 01:52:25 -07:00
EINA_MAIN_LOOP_CHECK_RETURN_VAL ( NULL ) ;
2012-10-10 01:19:58 -07:00
2011-07-28 05:01:16 -07:00
_ecore_lock ( ) ;
data = _ecore_idle_enterer_del ( idle_enterer ) ;
_ecore_unlock ( ) ;
return data ;
2003-09-23 01:09:32 -07:00
}
2010-10-17 00:03:28 -07:00
/**
* @ }
*/
2012-10-10 01:19:58 -07:00
2011-07-28 05:01:16 -07:00
static void *
2012-10-10 01:19:58 -07:00
_ecore_idle_enterer_del ( Ecore_Idle_Enterer * obj )
2011-07-28 05:01:16 -07:00
{
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * idle_enterer = eo_data_get ( obj , MY_CLASS ) ;
2011-07-28 05:01:16 -07:00
EINA_SAFETY_ON_TRUE_RETURN_VAL ( idle_enterer - > delete_me , NULL ) ;
idle_enterer - > delete_me = 1 ;
idle_enterers_delete_me = 1 ;
return idle_enterer - > data ;
}
2012-10-10 01:19:58 -07:00
static void
_destructor ( Eo * obj , void * _pd , va_list * list EINA_UNUSED )
{
Ecore_Idle_Enterer_Private_Data * idle_enterer = _pd ;
idle_enterer - > delete_me = 1 ;
idle_enterers_delete_me = 1 ;
eo_do_super ( obj , eo_destructor ( ) ) ;
}
2003-09-23 01:09:32 -07:00
void
_ecore_idle_enterer_shutdown ( void )
{
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * ie ;
2009-06-17 04:39:37 -07:00
while ( ( ie = idle_enterers ) )
2003-09-23 01:09:32 -07:00
{
2012-10-10 01:19:58 -07:00
idle_enterers = ( Ecore_Idle_Enterer_Private_Data * ) eina_inlist_remove ( EINA_INLIST_GET ( idle_enterers ) , EINA_INLIST_GET ( idle_enterers ) ) ;
eo_parent_set ( ie - > obj , NULL ) ;
if ( eo_destructed_is ( ie - > obj ) )
eo_manual_free ( ie - > obj ) ;
else
eo_manual_free_set ( ie - > obj , EINA_FALSE ) ;
2003-09-23 01:09:32 -07:00
}
idle_enterers_delete_me = 0 ;
Fix idle_enterers when using recursive main loops.
If an idle_enterer created a recursive main loop (just called
ecore_main_loop_begin()), then this recursive main loop should
continue to process idle_enterers from there and on, thus
idle_enterer_current was added. When going back from recursion, the
current iterator should be updated properly.
This patch also fixes the deletion of idle_enterers from recursive
main loops by reference counting them. This way, the node will not be
free()d inside inner loop cleanups and then crash when going back to
outer loop.
The following test case used to crash but not anymore:
#include <Ecore.h>
#include <Eina.h>
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static Ecore_Idle_Enterer *handle;
static int idler(void *data)
{
INF("idler");
return 1;
}
static int cb2(void *data)
{
INF("cb2 - delete cb1 handle");
ecore_idle_enterer_del(handle);
ecore_main_loop_quit(); /* quits inner main loop */
return 0;
}
static int cb1(void *data)
{
INF("cb1: begin");
INF(" add cb2");
ecore_idle_enterer_add(cb2, NULL);
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin(); /* will it crash due ecore_idle_enterer_del(handle)
* inside cb2()? It used to!
*/
INF("cb1: end");
ecore_main_loop_quit(); /* quits outer main loop */
return 0;
}
int main(void)
{
ecore_init();
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
/*
* Creating a new main loop from inside an idle_enterer callback,
* and inside this new (inner) main loop deleting the caller
* callback used to crash since the handle would be effectively
* free()d, but when the recursion is over the pointer would be
* used.
*/
INF("main: begin");
handle = ecore_idle_enterer_add(cb1, NULL);
ecore_idler_add(idler, NULL);
ecore_main_loop_begin();
INF("main: end");
return 0;
}
SVN revision: 46408
2010-02-23 14:13:42 -08:00
idle_enterer_current = NULL ;
2003-09-23 01:09:32 -07:00
}
void
_ecore_idle_enterer_call ( void )
{
Fix idle_enterers when using recursive main loops.
If an idle_enterer created a recursive main loop (just called
ecore_main_loop_begin()), then this recursive main loop should
continue to process idle_enterers from there and on, thus
idle_enterer_current was added. When going back from recursion, the
current iterator should be updated properly.
This patch also fixes the deletion of idle_enterers from recursive
main loops by reference counting them. This way, the node will not be
free()d inside inner loop cleanups and then crash when going back to
outer loop.
The following test case used to crash but not anymore:
#include <Ecore.h>
#include <Eina.h>
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static Ecore_Idle_Enterer *handle;
static int idler(void *data)
{
INF("idler");
return 1;
}
static int cb2(void *data)
{
INF("cb2 - delete cb1 handle");
ecore_idle_enterer_del(handle);
ecore_main_loop_quit(); /* quits inner main loop */
return 0;
}
static int cb1(void *data)
{
INF("cb1: begin");
INF(" add cb2");
ecore_idle_enterer_add(cb2, NULL);
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin(); /* will it crash due ecore_idle_enterer_del(handle)
* inside cb2()? It used to!
*/
INF("cb1: end");
ecore_main_loop_quit(); /* quits outer main loop */
return 0;
}
int main(void)
{
ecore_init();
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
/*
* Creating a new main loop from inside an idle_enterer callback,
* and inside this new (inner) main loop deleting the caller
* callback used to crash since the handle would be effectively
* free()d, but when the recursion is over the pointer would be
* used.
*/
INF("main: begin");
handle = ecore_idle_enterer_add(cb1, NULL);
ecore_idler_add(idler, NULL);
ecore_main_loop_begin();
INF("main: end");
return 0;
}
SVN revision: 46408
2010-02-23 14:13:42 -08:00
if ( ! idle_enterer_current )
{
2010-09-29 23:09:20 -07:00
/* regular main loop, start from head */
2011-10-20 22:40:39 -07:00
idle_enterer_current = idle_enterers ;
Fix idle_enterers when using recursive main loops.
If an idle_enterer created a recursive main loop (just called
ecore_main_loop_begin()), then this recursive main loop should
continue to process idle_enterers from there and on, thus
idle_enterer_current was added. When going back from recursion, the
current iterator should be updated properly.
This patch also fixes the deletion of idle_enterers from recursive
main loops by reference counting them. This way, the node will not be
free()d inside inner loop cleanups and then crash when going back to
outer loop.
The following test case used to crash but not anymore:
#include <Ecore.h>
#include <Eina.h>
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static Ecore_Idle_Enterer *handle;
static int idler(void *data)
{
INF("idler");
return 1;
}
static int cb2(void *data)
{
INF("cb2 - delete cb1 handle");
ecore_idle_enterer_del(handle);
ecore_main_loop_quit(); /* quits inner main loop */
return 0;
}
static int cb1(void *data)
{
INF("cb1: begin");
INF(" add cb2");
ecore_idle_enterer_add(cb2, NULL);
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin(); /* will it crash due ecore_idle_enterer_del(handle)
* inside cb2()? It used to!
*/
INF("cb1: end");
ecore_main_loop_quit(); /* quits outer main loop */
return 0;
}
int main(void)
{
ecore_init();
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
/*
* Creating a new main loop from inside an idle_enterer callback,
* and inside this new (inner) main loop deleting the caller
* callback used to crash since the handle would be effectively
* free()d, but when the recursion is over the pointer would be
* used.
*/
INF("main: begin");
handle = ecore_idle_enterer_add(cb1, NULL);
ecore_idler_add(idler, NULL);
ecore_main_loop_begin();
INF("main: end");
return 0;
}
SVN revision: 46408
2010-02-23 14:13:42 -08:00
}
else
{
2010-09-29 23:09:20 -07:00
/* recursive main loop, continue from where we were */
2011-10-20 22:40:39 -07:00
idle_enterer_current =
2012-10-10 01:19:58 -07:00
( Ecore_Idle_Enterer_Private_Data * ) EINA_INLIST_GET ( idle_enterer_current ) - > next ;
Fix idle_enterers when using recursive main loops.
If an idle_enterer created a recursive main loop (just called
ecore_main_loop_begin()), then this recursive main loop should
continue to process idle_enterers from there and on, thus
idle_enterer_current was added. When going back from recursion, the
current iterator should be updated properly.
This patch also fixes the deletion of idle_enterers from recursive
main loops by reference counting them. This way, the node will not be
free()d inside inner loop cleanups and then crash when going back to
outer loop.
The following test case used to crash but not anymore:
#include <Ecore.h>
#include <Eina.h>
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static Ecore_Idle_Enterer *handle;
static int idler(void *data)
{
INF("idler");
return 1;
}
static int cb2(void *data)
{
INF("cb2 - delete cb1 handle");
ecore_idle_enterer_del(handle);
ecore_main_loop_quit(); /* quits inner main loop */
return 0;
}
static int cb1(void *data)
{
INF("cb1: begin");
INF(" add cb2");
ecore_idle_enterer_add(cb2, NULL);
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin(); /* will it crash due ecore_idle_enterer_del(handle)
* inside cb2()? It used to!
*/
INF("cb1: end");
ecore_main_loop_quit(); /* quits outer main loop */
return 0;
}
int main(void)
{
ecore_init();
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
/*
* Creating a new main loop from inside an idle_enterer callback,
* and inside this new (inner) main loop deleting the caller
* callback used to crash since the handle would be effectively
* free()d, but when the recursion is over the pointer would be
* used.
*/
INF("main: begin");
handle = ecore_idle_enterer_add(cb1, NULL);
ecore_idler_add(idler, NULL);
ecore_main_loop_begin();
INF("main: end");
return 0;
}
SVN revision: 46408
2010-02-23 14:13:42 -08:00
}
2008-11-29 03:23:17 -08:00
Fix idle_enterers when using recursive main loops.
If an idle_enterer created a recursive main loop (just called
ecore_main_loop_begin()), then this recursive main loop should
continue to process idle_enterers from there and on, thus
idle_enterer_current was added. When going back from recursion, the
current iterator should be updated properly.
This patch also fixes the deletion of idle_enterers from recursive
main loops by reference counting them. This way, the node will not be
free()d inside inner loop cleanups and then crash when going back to
outer loop.
The following test case used to crash but not anymore:
#include <Ecore.h>
#include <Eina.h>
static int _log_dom;
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
static Ecore_Idle_Enterer *handle;
static int idler(void *data)
{
INF("idler");
return 1;
}
static int cb2(void *data)
{
INF("cb2 - delete cb1 handle");
ecore_idle_enterer_del(handle);
ecore_main_loop_quit(); /* quits inner main loop */
return 0;
}
static int cb1(void *data)
{
INF("cb1: begin");
INF(" add cb2");
ecore_idle_enterer_add(cb2, NULL);
INF(" inner main loop begin (recurse)");
ecore_main_loop_begin(); /* will it crash due ecore_idle_enterer_del(handle)
* inside cb2()? It used to!
*/
INF("cb1: end");
ecore_main_loop_quit(); /* quits outer main loop */
return 0;
}
int main(void)
{
ecore_init();
_log_dom = eina_log_domain_register("test", EINA_COLOR_CYAN);
/*
* Creating a new main loop from inside an idle_enterer callback,
* and inside this new (inner) main loop deleting the caller
* callback used to crash since the handle would be effectively
* free()d, but when the recursion is over the pointer would be
* used.
*/
INF("main: begin");
handle = ecore_idle_enterer_add(cb1, NULL);
ecore_idler_add(idler, NULL);
ecore_main_loop_begin();
INF("main: end");
return 0;
}
SVN revision: 46408
2010-02-23 14:13:42 -08:00
while ( idle_enterer_current )
2003-09-23 01:09:32 -07:00
{
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * ie = ( Ecore_Idle_Enterer_Private_Data * ) idle_enterer_current ;
2010-09-29 23:09:20 -07:00
if ( ! ie - > delete_me )
{
ie - > references + + ;
2011-08-11 03:59:48 -07:00
if ( ! _ecore_call_task_cb ( ie - > func , ie - > data ) )
2010-09-29 23:09:20 -07:00
{
2012-10-10 01:19:58 -07:00
if ( ! ie - > delete_me ) _ecore_idle_enterer_del ( ie - > obj ) ;
2010-09-29 23:09:20 -07:00
}
ie - > references - - ;
}
if ( idle_enterer_current ) /* may have changed in recursive main loops */
idle_enterer_current =
2012-10-10 01:19:58 -07:00
( Ecore_Idle_Enterer_Private_Data * ) EINA_INLIST_GET ( idle_enterer_current ) - > next ;
2003-09-23 01:09:32 -07:00
}
if ( idle_enterers_delete_me )
{
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * l ;
2010-09-29 23:09:20 -07:00
int deleted_idler_enterers_in_use = 0 ;
2011-10-20 22:40:39 -07:00
for ( l = idle_enterers ; l ; )
2010-09-29 23:09:20 -07:00
{
2012-10-10 01:19:58 -07:00
Ecore_Idle_Enterer_Private_Data * ie = l ;
l = ( Ecore_Idle_Enterer_Private_Data * ) EINA_INLIST_GET ( l ) - > next ;
2010-09-29 23:09:20 -07:00
if ( ie - > delete_me )
{
if ( ie - > references )
{
deleted_idler_enterers_in_use + + ;
continue ;
}
2012-10-10 01:19:58 -07:00
idle_enterers = ( Ecore_Idle_Enterer_Private_Data * ) eina_inlist_remove ( EINA_INLIST_GET ( idle_enterers ) , EINA_INLIST_GET ( ie ) ) ;
eo_parent_set ( ie - > obj , NULL ) ;
if ( eo_destructed_is ( ie - > obj ) )
eo_manual_free ( ie - > obj ) ;
else
eo_manual_free_set ( ie - > obj , EINA_FALSE ) ;
2010-09-29 23:09:20 -07:00
}
}
if ( ! deleted_idler_enterers_in_use )
idle_enterers_delete_me = 0 ;
2003-09-23 01:09:32 -07:00
}
}
int
_ecore_idle_enterer_exist ( void )
{
if ( idle_enterers ) return 1 ;
return 0 ;
}
2011-10-20 22:40:39 -07:00
2012-10-10 01:19:58 -07:00
static void
_class_constructor ( Eo_Class * klass )
{
const Eo_Op_Func_Description func_desc [ ] = {
EO_OP_FUNC ( EO_BASE_ID ( EO_BASE_SUB_ID_CONSTRUCTOR ) , _constructor ) ,
EO_OP_FUNC ( EO_BASE_ID ( EO_BASE_SUB_ID_DESTRUCTOR ) , _destructor ) ,
EO_OP_FUNC ( ECORE_IDLE_ENTERER_ID ( ECORE_IDLE_ENTERER_SUB_ID_AFTER_CONSTRUCTOR ) , _idle_enterer_after_constructor ) ,
EO_OP_FUNC ( ECORE_IDLE_ENTERER_ID ( ECORE_IDLE_ENTERER_SUB_ID_BEFORE_CONSTRUCTOR ) , _idle_enterer_before_constructor ) ,
EO_OP_FUNC_SENTINEL
} ;
eo_class_funcs_set ( klass , func_desc ) ;
}
static const Eo_Op_Description op_desc [ ] = {
EO_OP_DESCRIPTION ( ECORE_IDLE_ENTERER_SUB_ID_AFTER_CONSTRUCTOR , " Add an idle enterer handler. " ) ,
EO_OP_DESCRIPTION ( ECORE_IDLE_ENTERER_SUB_ID_BEFORE_CONSTRUCTOR , " Add an idle enterer handler at the start of the list so it gets called earlier than others. " ) ,
EO_OP_DESCRIPTION_SENTINEL
} ;
static const Eo_Class_Description class_desc = {
EO_VERSION ,
MY_CLASS_NAME ,
EO_CLASS_TYPE_REGULAR ,
EO_CLASS_DESCRIPTION_OPS ( & ECORE_IDLE_ENTERER_BASE_ID , op_desc , ECORE_IDLE_ENTERER_SUB_ID_LAST ) ,
NULL ,
sizeof ( Ecore_Idle_Enterer_Private_Data ) ,
_class_constructor ,
NULL
} ;
EO_DEFINE_CLASS ( ecore_idle_enterer_class_get , & class_desc , EO_BASE_CLASS , NULL )