From: antognolli Date: Wed, 29 Jun 2011 18:07:08 +0000 (+0000) Subject: ecore/timer - Add a commented example. X-Git-Tag: 2.0_alpha~194^2~25 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=3338df464694222e58487d0dec07bc691a2f65e6;p=framework%2Fuifw%2Fecore.git ecore/timer - Add a commented example. git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/ecore@60827 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33 --- diff --git a/doc/examples.dox b/doc/examples.dox index 06330b2..7f6746e 100644 --- a/doc/examples.dox +++ b/doc/examples.dox @@ -4,9 +4,11 @@ * Here is a page with some Ecore examples explained: * * @li @ref ecore_time_example_c + * @li @ref ecore_timer_example_c * @li @ref ecore_idler_example_c * @li @ref ecore_job_example_c * @li @ref ecore_event_example_c + * @li @ref ecore_fd_handler_example_c * */ @@ -41,6 +43,79 @@ */ /** + * @page ecore_timer_example_c ecore timers - Timed events + * @dontinclude ecore_timer_example.c + * + * This example shows how to setup timer callbacks. It starts a timer that will + * tick (expire) every 1 second, and then setup other timers that will expire + * only once, but each of them will affect the firts timer still executing with + * a different API, to demonstrate its usage. To see the full code for this + * example, click @ref ecore_timer_example.c "here". + * + * To demonstrate this, let's define some constants that will determine at which + * time each timer will expire: + * + * @until INTERVAL1 + * + * These constants should tell by themselves what will be the behavior of the + * program, but I'll explain it anyway. The first timer is set to tick every 1 + * second, but all the other timers until the 6th one will be started + * concurrently at the beginning of the program. Each of them will expire at the + * specified time in these constants: + * + * @li The timer2, after 3 seconds of the program being executed, will add a delay + * of 3 seconds to timer1; + * @li The timer3 will pause timer1 at 8.2 seconds; + * @li timer4 will resume timer1 at 11.0 seconds; + * @li timer5 will will change the interval of timer1 to 2 seconds; + * @li timer6 will stop timer1 and start timer7 and timer8, with 1.1 and 1.2 + * seconds of interval, respectively; it also sets the precision to 0.2 seconds; + * @li timer7 and timer8 will just print their expiration time. + * + * @until ecore_time_get + * @until } + * + * As almost all the other examples, we create a context structure to pass to + * our callbacks, so they can have access to the other timers. We also store the + * time of the program start in @c _initial_time, and use the function + * @c _get_current_time to retrieve the current time relative to that time. This + * will help demonstrate what is going on. + * + * Now, the behavior and relationship between the timers that was described + * above is dictated by the following timer callbacks: + * + * @until _timer6_cb + * @until } + * + * It's possible to see the same behavior as other Ecore callbacks here, + * returning @ref ECORE_CALLBACK_RENEW when the timer needs to continue ticking, + * and @ref ECORE_CALLBACK_CANCEL when it needs to stop its execution. Also + * notice that later on our program we are checking for the timers pointers in + * the context to see if they are still executing before deleting them, so we + * need to set these timer pointers to @c NULL when we are returning @ref + * ECORE_CALLBACK_CANCEL. Otherwise the pointer would still be not @c NULL, but + * pointing to something that is invalid, since the timer would have already + * expired without renewing. + * + * Now the main code, which will start the timers: + * + * @until ecore_shutdown + * @until } + * + * This code is very simple. Just after starting the library, it will save the + * current time to @c _initial_time, start all timers from 1 to 6, and begin the + * main loop. Everything should be running right now, displaying the time which + * each timer is expiring, and what it is doing to affect the other timers. + * + * After returning from the main loop, every timer is checked to see if it's + * still alive and, in that case, deleted, before finalizing the library. This + * is not really necessary, since ecore_shutdown() will already delete them for + * you, but it's good practice if you have other things going on after this + * point that could restart the main loop. + * + */ + +/** * @page ecore_idler_example_c ecore idle state - Idlers, enterers and exiters * * This example demonstrates how to manage the idle state of the main loop. Once @@ -218,13 +293,15 @@ */ /** - * @page ecore_event_example_c ecore fd handlers - Monitoring file descriptors + * @page ecore_fd_handler_example_c ecore fd handlers - Monitoring file descriptors * @dontinclude ecore_fd_handler_example.c * * This is a very simple example where we will start monitoring the stdin of the * program and, whenever there's something to be read, we call our callback that * will read it. * + * Check the full code for this example @ref ecore_fd_handler_example.c "here". + * * This seems to be stupid, since a similar result could be achieved by the * following code: * @@ -334,6 +411,12 @@ */ /** + * @example ecore_timer_example.c + * This example show how to use timers to have timed events inside ecore. + * See @ref ecore_timer_example_c "the example explained". + */ + +/** * @example ecore_fd_handler_example.c * This example shows how to setup and use an fd_handler. See * @ref ecore_fd_handler_example_c "the explanation here". diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am index 76d0272..61c9950 100644 --- a/src/examples/Makefile.am +++ b/src/examples/Makefile.am @@ -15,6 +15,7 @@ SRCS = \ ecore_fd_handler_example.c \ ecore_event_example.c \ ecore_idler_example.c \ + ecore_timer_example.c \ ecore_time_example.c \ ecore_job_example.c \ client_bench.c \ @@ -39,6 +40,7 @@ pkglib_PROGRAMS += \ ecore_event_example \ ecore_idler_example \ ecore_job_example \ + ecore_timer_example \ ecore_time_example endif diff --git a/src/examples/ecore_timer_example.c b/src/examples/ecore_timer_example.c new file mode 100644 index 0000000..2d5d368 --- /dev/null +++ b/src/examples/ecore_timer_example.c @@ -0,0 +1,184 @@ +#include +#include + +#define TIMEOUT_1 1.0 // interval for timer1 +#define TIMEOUT_2 3.0 // timer2 - delay timer1 +#define TIMEOUT_3 8.2 // timer3 - pause timer1 +#define TIMEOUT_4 11.0 // timer4 - resume timer1 +#define TIMEOUT_5 14.0 // timer5 - change interval of timer1 +#define TIMEOUT_6 18.0 // top timer1 and start timer7 and timer8 with changed precision +#define TIMEOUT_7 1.1 // interval for timer7 +#define TIMEOUT_8 1.2 // interval for timer8 +#define DELAY_1 3.0 // delay time for timer1 - used by timer2 +#define INTERVAL1 2.0 // new interval for timer1 - used by timer5 + +static double _initial_time = 0; + +struct context { // helper struct to give some context to the callbacks + Ecore_Timer *timer1; + Ecore_Timer *timer2; + Ecore_Timer *timer3; + Ecore_Timer *timer4; + Ecore_Timer *timer5; + Ecore_Timer *timer6; + Ecore_Timer *timer7; + Ecore_Timer *timer8; +}; + +static double +_get_current_time(void) +{ + return ecore_time_get() - _initial_time; +} + +static Eina_Bool +_timer1_cb(void *data) +{ + printf("Timer1 expired after %0.3f seconds.\n", _get_current_time()); + return ECORE_CALLBACK_RENEW; +} + +static Eina_Bool +_timer2_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer2 expired after %0.3f seconds. " + "Adding delay of %0.3f seconds to timer1.\n", + _get_current_time(), DELAY_1); + + ecore_timer_delay(ctxt->timer1, DELAY_1); + + ctxt->timer2 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer3_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer3 expired after %0.3f seconds. " + "Freezing timer1.\n", _get_current_time()); + + ecore_timer_freeze(ctxt->timer1); + + ctxt->timer3 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer4_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer4 expired after %0.3f seconds. " + "Resuming timer1, which has %0.3f seconds left to expire.\n", + _get_current_time(), ecore_timer_pending_get(ctxt->timer1)); + + ecore_timer_thaw(ctxt->timer1); + + ctxt->timer4 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer5_cb(void *data) +{ + struct context *ctxt = data; + double interval = ecore_timer_interval_get(ctxt->timer1); + + printf("Timer5 expired after %0.3f seconds. " + "Changing interval of timer1 from %0.3f to %0.3f seconds.\n", + _get_current_time(), interval, INTERVAL1); + + ecore_timer_interval_set(ctxt->timer1, INTERVAL1); + + ctxt->timer5 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer7_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer7 expired after %0.3f seconds.\n", _get_current_time()); + + ctxt->timer7 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer8_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer8 expired after %0.3f seconds.\n", _get_current_time()); + + ctxt->timer8 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +static Eina_Bool +_timer6_cb(void *data) +{ + struct context *ctxt = data; + printf("Timer6 expired after %0.3f seconds.\n", _get_current_time()); + + printf("Stopping timer1.\n"); + + ecore_timer_del(ctxt->timer1); + ctxt->timer1 = NULL; + + printf("Starting timer7 (%0.3fs) and timer8 (%0.3fs).\n", + TIMEOUT_7, TIMEOUT_8); + + ctxt->timer7 = ecore_timer_add(TIMEOUT_7, _timer7_cb, ctxt); + ctxt->timer8 = ecore_timer_add(TIMEOUT_8, _timer8_cb, ctxt); + + ecore_timer_precision_set(0.2); + + ctxt->timer6 = NULL; + return ECORE_CALLBACK_CANCEL; +} + +int main(int argc, char **argv) +{ + struct context ctxt = {0}; + + if (!ecore_init()) + { + printf("ERROR: Cannot init Ecore!\n"); + return -1; + } + + _initial_time = ecore_time_get(); + + ctxt.timer1 = ecore_timer_add(TIMEOUT_1, _timer1_cb, &ctxt); + ctxt.timer2 = ecore_timer_add(TIMEOUT_2, _timer2_cb, &ctxt); + ctxt.timer3 = ecore_timer_add(TIMEOUT_3, _timer3_cb, &ctxt); + ctxt.timer4 = ecore_timer_add(TIMEOUT_4, _timer4_cb, &ctxt); + ctxt.timer5 = ecore_timer_add(TIMEOUT_5, _timer5_cb, &ctxt); + ctxt.timer6 = ecore_timer_add(TIMEOUT_6, _timer6_cb, &ctxt); + + printf("start the main loop.\n"); + + ecore_main_loop_begin(); + + if (ctxt.timer1) + ecore_timer_del(ctxt.timer1); + if (ctxt.timer2) + ecore_timer_del(ctxt.timer2); + if (ctxt.timer3) + ecore_timer_del(ctxt.timer3); + if (ctxt.timer4) + ecore_timer_del(ctxt.timer4); + if (ctxt.timer5) + ecore_timer_del(ctxt.timer5); + if (ctxt.timer6) + ecore_timer_del(ctxt.timer6); + if (ctxt.timer7) + ecore_timer_del(ctxt.timer7); + if (ctxt.timer8) + ecore_timer_del(ctxt.timer8); + + ecore_shutdown(); + + return 0; +}