ecore_idler_example.c

This example shows when Ecore_Idler, Ecore_Idle_Enterer and Ecore_Idle_Exiter are called.

This example shows when Ecore_Idler, Ecore_Idle_Enterer and Ecore_Idle_Exiter are called. See the explanation here.

//Compile with:
// gcc -o ecore_idler_example ecore_idler_example.c `pkg-config --libs --cflags ecore eo`
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <Ecore.h>
#include <Eo.h>
#include <unistd.h>
struct context // helper struct to give some context to the callbacks
{
int count;
Ecore_Idle_Enterer *enterer;
Ecore_Idler *idler;
Ecore_Idle_Exiter *exiter;
Ecore_Event_Handler *handler;
Ecore_Timer *timer;
};
static int _event_type = 0; // a new type of event will be defined and stored here
static Eina_Bool
_enterer_cb(void *data EINA_UNUSED) // the idle enterer callback
{
printf("IDLE ENTERER: Ecore entering in idle state.\n");
return ECORE_CALLBACK_RENEW; // same as EINA_TRUE
}
static Eina_Bool
_exiter_cb(void *data EINA_UNUSED) // the idle exiter callback
{
printf("IDLE EXITER: Ecore exiting idle state.\n");
return ECORE_CALLBACK_RENEW; // same as EINA_TRUE
}
static Eina_Bool
_idler_cb(void *data) // the idler callback - ran while the mainloop is idle
{
struct context *ctxt = data;
printf("IDLER: executing idler callback while in idle state.\n");
ctxt->count++;
/* each 10 times that the callback gets called, generate an event that
* will wake up the main loop, triggering idle enterers, exiters, etc. */
if ((ctxt->count % 10) == 0)
ecore_event_add(_event_type, NULL, NULL, NULL);
return ECORE_CALLBACK_RENEW; // same as EINA_TRUE
}
static Eina_Bool
_event_handler_cb(void *data, int type EINA_UNUSED, void *event EINA_UNUSED) // event callback
{
struct context *ctxt = data;
printf("EVENT: processing callback for the event received.\n");
if (ctxt->count > 100)
{
ecore_idle_enterer_del(ctxt->enterer);
ecore_idle_exiter_del(ctxt->exiter);
// ecore_idler_del(ctxt->idler);
ctxt->enterer = NULL;
ctxt->exiter = NULL;
ctxt->idler = NULL;
if (ctxt->timer)
{
ecore_timer_del(ctxt->timer);
ctxt->timer = NULL;
}
ecore_main_loop_quit();
}
return ECORE_CALLBACK_DONE; // same as EINA_FALSE
}
static Eina_Bool
_timer_cb(void *data)
{
struct context *ctxt = data;
printf("TIMER: timer callback called.\n");
if (ctxt->timer)
ctxt->timer = NULL;
return ECORE_CALLBACK_CANCEL; // same as EINA_FALSE
}
int
main(void)
{
struct context ctxt = {0};
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_event_type = ecore_event_type_new();
ctxt.enterer = ecore_idle_enterer_add(_enterer_cb, &ctxt);
ctxt.exiter = ecore_idle_exiter_add(_exiter_cb, &ctxt);
ctxt.idler = ecore_idler_add(_idler_cb, &ctxt);
// ctxt.idler = efl_add_ref(ECORE_IDLER_CLASS, NULL, ecore_idler_constructor(efl_added, _idler_cb, &ctxt));
ctxt.handler = ecore_event_handler_add(_event_type,
_event_handler_cb,
&ctxt);
ctxt.timer = ecore_timer_add(0.0005, _timer_cb, &ctxt);
ecore_main_loop_begin();
ecore_shutdown();
return 0;
}
Ecore_Event_Handler
struct _Ecore_Event_Handler Ecore_Event_Handler
A handle for an event handler.
Definition Ecore_Common.h:576
ecore_event_type_new
int ecore_event_type_new(void)
Allocates a new event type id sensibly and returns the new id.
Definition ecore_events.c:80
ecore_event_add
Ecore_Event * ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data)
Adds an event to the event queue.
Definition ecore_events.c:52
ecore_event_handler_add
Ecore_Event_Handler * ecore_event_handler_add(int type, Ecore_Event_Handler_Cb func, const void *data)
Adds an event handler.
Definition ecore_events.c:13
ecore_idle_enterer_add
Ecore_Idle_Enterer * ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data)
Adds an idle enterer handler.
Definition ecore_idle_enterer.c:18
ecore_idle_exiter_del
void * ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
Deletes an idle exiter handler from the list to be run on exiting idle state.
Definition ecore_idle_exiter.c:24
Ecore_Idle_Exiter
struct _Ecore_Factorized_Idle Ecore_Idle_Exiter
A handle for idle exiters.
Definition Ecore_Common.h:3195
ecore_idler_add
Ecore_Idler * ecore_idler_add(Ecore_Task_Cb func, const void *data)
Adds an idler handler.
Definition ecore_idler.c:109
ecore_idle_enterer_del
void * ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer)
Deletes an idle enterer callback.
Definition ecore_idle_enterer.c:40
Ecore_Idle_Enterer
struct _Ecore_Factorized_Idle Ecore_Idle_Enterer
A handle for idle enterers.
Definition Ecore_Common.h:3190
ecore_idle_exiter_add
Ecore_Idle_Exiter * ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data)
Adds an idle exiter handler.
Definition ecore_idle_exiter.c:17
Ecore_Idler
struct _Ecore_Factorized_Idle Ecore_Idler
A handle for idlers.
Definition Ecore_Common.h:3185
ecore_shutdown
EAPI int ecore_shutdown(void)
Shuts down connections, signal handlers sockets etc.
Definition ecore.c:371
ecore_init
EAPI int ecore_init(void)
Sets up connections, signal handlers, sockets etc.
Definition ecore.c:230
ECORE_CALLBACK_RENEW
#define ECORE_CALLBACK_RENEW
Return value to keep a callback.
Definition Ecore_Common.h:153
ECORE_CALLBACK_DONE
#define ECORE_CALLBACK_DONE
Return value to stop event handling.
Definition Ecore_Common.h:156
ecore_main_loop_quit
void ecore_main_loop_quit(void)
Quits the main loop once all the events currently on the queue have been processed.
Definition ecore_main.c:1321
ECORE_CALLBACK_CANCEL
#define ECORE_CALLBACK_CANCEL
Return value to remove a callback.
Definition Ecore_Common.h:152
ecore_main_loop_begin
void ecore_main_loop_begin(void)
Runs the application main loop.
Definition ecore_main.c:1311
ecore_timer_del
void * ecore_timer_del(Ecore_Timer *timer)
Deletes the specified timer from the timer list.
Definition ecore_timer.c:238
ecore_timer_add
Ecore_Timer * ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
Creates a timer to call the given function in the given period of time.
Definition ecore_timer.c:189
Ecore_Timer
Eo Ecore_Timer
A handle for timers.
Definition Ecore_Common.h:3085
Eina_Bool
unsigned char Eina_Bool
Type to mimic a boolean.
Definition eina_types.h:527
EINA_UNUSED
#define EINA_UNUSED
Used to indicate that a function parameter is purposely unused.
Definition eina_types.h:339