main loop checks for all of ecore -> back. (removed by cedric last year)

git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/ecore@69727 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/src/lib/ecore/ecore_anim.c b/src/lib/ecore/ecore_anim.c
index 22c1f8c..4ced67a 100644 (file)
--- a/src/lib/ecore/ecore_anim.c
+++ b/src/lib/ecore/ecore_anim.c
@@ -169,6 +169,7 @@ ecore_animator_add(Ecore_Task_Cb func,
 {
    Ecore_Animator *animator;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    animator = _ecore_animator_add(func, data);
    _ecore_unlock();
@@ -183,6 +184,7 @@ ecore_animator_timeline_add(double            runtime,
 {
    Ecore_Animator *animator;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (runtime <= 0.0) runtime = 0.0;
    animator = _ecore_animator_add(_ecore_animator_run, NULL);
@@ -321,6 +323,7 @@ ecore_animator_del(Ecore_Animator *animator)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(animator, ECORE_MAGIC_ANIMATOR))
      {
@@ -347,6 +350,7 @@ unlock:
 EAPI void
 ecore_animator_frametime_set(double frametime)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    if (frametime < 0.0) frametime = 0.0;
    if (animators_frametime == frametime) goto unlock;
@@ -360,12 +364,14 @@ unlock:
 EAPI double
 ecore_animator_frametime_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    return animators_frametime;
 }
 
 EAPI void
 ecore_animator_freeze(Ecore_Animator *animator)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(animator, ECORE_MAGIC_ANIMATOR))
      {
@@ -382,6 +388,7 @@ unlock:
 EAPI void
 ecore_animator_thaw(Ecore_Animator *animator)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(animator, ECORE_MAGIC_ANIMATOR))
      {
@@ -398,6 +405,7 @@ unlock:
 EAPI void
 ecore_animator_source_set(Ecore_Animator_Source source)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    src = source;
    _end_tick();
@@ -408,6 +416,7 @@ ecore_animator_source_set(Ecore_Animator_Source source)
 EAPI Ecore_Animator_Source
 ecore_animator_source_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    return src;
 }
 
@@ -415,6 +424,7 @@ EAPI void
 ecore_animator_custom_source_tick_begin_callback_set(Ecore_Cb    func,
                                                      const void *data)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    begin_tick_cb = func;
    begin_tick_data = data;
@@ -427,6 +437,7 @@ EAPI void
 ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb    func,
                                                    const void *data)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    end_tick_cb = func;
    end_tick_data = data;
@@ -438,6 +449,7 @@ ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb    func,
 EAPI void
 ecore_animator_custom_tick(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
    if (src == ECORE_ANIMATOR_SOURCE_CUSTOM) _do_tick();
    _ecore_unlock();

diff --git a/src/lib/ecore/ecore_app.c b/src/lib/ecore/ecore_app.c
index 5e4bf02..6e73da0 100644 (file)
--- a/src/lib/ecore/ecore_app.c
+++ b/src/lib/ecore/ecore_app.c
@@ -78,6 +78,7 @@ ecore_app_args_get(int    *argc,
 EAPI void
 ecore_app_restart(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
 #ifdef HAVE_EXECVP
    char *args[4096];
    int i;

diff --git a/src/lib/ecore/ecore_events.c b/src/lib/ecore/ecore_events.c
index 500cf74..a39416b 100644 (file)
--- a/src/lib/ecore/ecore_events.c
+++ b/src/lib/ecore/ecore_events.c
@@ -79,6 +79,7 @@ ecore_event_handler_add(int                    type,
 {
    Ecore_Event_Handler *eh = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if (!func) goto unlock;
@@ -127,6 +128,7 @@ ecore_event_handler_del(Ecore_Event_Handler *event_handler)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(event_handler, ECORE_MAGIC_EVENT_HANDLER))
      {
@@ -146,6 +148,7 @@ ecore_event_handler_data_get(Ecore_Event_Handler *eh)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
      {
@@ -164,6 +167,7 @@ ecore_event_handler_data_set(Ecore_Event_Handler *eh,
 {
    void *old = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
      {
@@ -193,6 +197,7 @@ ecore_event_add(int          type,
 {
    Ecore_Event *event = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
 /*   if (!ev) goto unlock; */
@@ -210,6 +215,7 @@ ecore_event_del(Ecore_Event *event)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(event, ECORE_MAGIC_EVENT))
      {
@@ -229,6 +235,7 @@ ecore_event_type_new(void)
 {
    int id;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    _ecore_lock();
    id = event_id_max++;
    _ecore_unlock();
@@ -244,6 +251,7 @@ ecore_event_filter_add(Ecore_Data_Cb   func_start,
 {
    Ecore_Event_Filter *ef = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!func_filter) goto unlock;
    ef = ecore_event_filter_calloc(1);
@@ -264,6 +272,7 @@ ecore_event_filter_del(Ecore_Event_Filter *ef)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!ECORE_MAGIC_CHECK(ef, ECORE_MAGIC_EVENT_FILTER))
      {
@@ -283,12 +292,14 @@ unlock:
 EAPI int
 ecore_event_current_type_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    return ecore_raw_event_type;
 }
 
 EAPI void *
 ecore_event_current_event_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    return ecore_raw_event_event;
 }
 

diff --git a/src/lib/ecore/ecore_exe.c b/src/lib/ecore/ecore_exe.c
index 47f8dc9..958df4c 100644 (file)
--- a/src/lib/ecore/ecore_exe.c
+++ b/src/lib/ecore/ecore_exe.c
@@ -344,6 +344,7 @@ static int run_pri = ECORE_EXE_PRIORITY_INHERIT;
 EAPI void
 ecore_exe_run_priority_set(int pri)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    run_pri = pri;
 }
 
@@ -359,6 +360,7 @@ ecore_exe_run_priority_set(int pri)
 EAPI int
 ecore_exe_run_priority_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    return run_pri;
 }
 
@@ -375,6 +377,7 @@ EAPI Ecore_Exe *
 ecore_exe_run(const char *exe_cmd,
               const void *data)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    return ecore_exe_pipe_run(exe_cmd, 0, data);
 }
 
@@ -417,6 +420,7 @@ ecore_exe_pipe_run(const char     *exe_cmd,
    int ok = 1;
    int result;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!exe_cmd) return NULL;
    exe = calloc(1, sizeof(Ecore_Exe));
    if (!exe) return NULL;
@@ -709,6 +713,7 @@ EAPI void
 ecore_exe_callback_pre_free_set(Ecore_Exe   *exe,
                                 Ecore_Exe_Cb func)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE,
@@ -737,6 +742,7 @@ ecore_exe_send(Ecore_Exe  *exe,
 {
    void *buf;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_send");
@@ -778,6 +784,7 @@ ecore_exe_send(Ecore_Exe  *exe,
 EAPI void
 ecore_exe_close_stdin(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_close_stdin");
@@ -803,6 +810,7 @@ ecore_exe_auto_limits_set(Ecore_Exe *exe,
                           int        start_lines,
                           int        end_lines)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_auto_limits_set");
@@ -869,6 +877,7 @@ ecore_exe_event_data_get(Ecore_Exe      *exe,
    unsigned char *inbuf;
    int inbuf_num;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_event_data_get");
@@ -995,6 +1004,7 @@ EAPI void
 ecore_exe_tag_set(Ecore_Exe  *exe,
                   const char *tag)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_tag_set");
@@ -1021,6 +1031,7 @@ ecore_exe_tag_set(Ecore_Exe  *exe,
 EAPI const char *
 ecore_exe_tag_get(const Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_tag_get");
@@ -1046,6 +1057,7 @@ ecore_exe_free(Ecore_Exe *exe)
    int ok = 0;
    int result;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_free");
@@ -1120,6 +1132,7 @@ ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
 EAPI pid_t
 ecore_exe_pid_get(const Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_pid_get");
@@ -1138,6 +1151,7 @@ ecore_exe_pid_get(const Ecore_Exe *exe)
 EAPI const char *
 ecore_exe_cmd_get(const Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_cmd_get");
@@ -1155,6 +1169,7 @@ ecore_exe_cmd_get(const Ecore_Exe *exe)
 EAPI void *
 ecore_exe_data_get(const Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_data_get");
@@ -1176,6 +1191,7 @@ ecore_exe_data_set(Ecore_Exe *exe,
                    void      *data)
 {
    void *ret;
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, __func__);
@@ -1194,6 +1210,7 @@ ecore_exe_data_set(Ecore_Exe *exe,
 EAPI Ecore_Exe_Flags
 ecore_exe_flags_get(const Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_data_get");
@@ -1209,6 +1226,7 @@ ecore_exe_flags_get(const Ecore_Exe *exe)
 EAPI void
 ecore_exe_pause(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_pause");
@@ -1224,6 +1242,7 @@ ecore_exe_pause(Ecore_Exe *exe)
 EAPI void
 ecore_exe_continue(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_continue");
@@ -1239,6 +1258,7 @@ ecore_exe_continue(Ecore_Exe *exe)
 EAPI void
 ecore_exe_interrupt(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_interrupt");
@@ -1255,6 +1275,7 @@ ecore_exe_interrupt(Ecore_Exe *exe)
 EAPI void
 ecore_exe_quit(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_quit");
@@ -1271,6 +1292,7 @@ ecore_exe_quit(Ecore_Exe *exe)
 EAPI void
 ecore_exe_terminate(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_terminate");
@@ -1290,6 +1312,7 @@ ecore_exe_kill(Ecore_Exe *exe)
 {
    struct _ecore_exe_dead_exe *dead;
 
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_kill");
@@ -1320,6 +1343,7 @@ EAPI void
 ecore_exe_signal(Ecore_Exe *exe,
                  int        num)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_signal");
@@ -1338,6 +1362,7 @@ ecore_exe_signal(Ecore_Exe *exe,
 EAPI void
 ecore_exe_hup(Ecore_Exe *exe)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
    {
       ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_hup");

diff --git a/src/lib/ecore/ecore_idle_enterer.c b/src/lib/ecore/ecore_idle_enterer.c
index 8e4ae50..73e72cb 100644 (file)
--- a/src/lib/ecore/ecore_idle_enterer.c
+++ b/src/lib/ecore/ecore_idle_enterer.c
@@ -47,6 +47,7 @@ ecore_idle_enterer_add(Ecore_Task_Cb func,
 {
    Ecore_Idle_Enterer *ie = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if (!func) goto unlock;
@@ -77,6 +78,7 @@ ecore_idle_enterer_before_add(Ecore_Task_Cb func,
 {
    Ecore_Idle_Enterer *ie = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if (!func) goto unlock;
@@ -102,6 +104,7 @@ ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer)
 {
    void *data;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(idle_enterer, ECORE_MAGIC_IDLE_ENTERER))
      {
         ECORE_MAGIC_FAIL(idle_enterer, ECORE_MAGIC_IDLE_ENTERER,

diff --git a/src/lib/ecore/ecore_idle_exiter.c b/src/lib/ecore/ecore_idle_exiter.c
index 4e454e2..0086bb6 100644 (file)
--- a/src/lib/ecore/ecore_idle_exiter.c
+++ b/src/lib/ecore/ecore_idle_exiter.c
@@ -46,6 +46,7 @@ ecore_idle_exiter_add(Ecore_Task_Cb func,
 {
    Ecore_Idle_Exiter *ie = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!func) goto unlock;
    ie = ecore_idle_exiter_calloc(1);
@@ -70,6 +71,7 @@ ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
 {
    void *data;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(idle_exiter, ECORE_MAGIC_IDLE_EXITER))
      {
         ECORE_MAGIC_FAIL(idle_exiter, ECORE_MAGIC_IDLE_EXITER,

diff --git a/src/lib/ecore/ecore_idler.c b/src/lib/ecore/ecore_idler.c
index 5114654..62998b6 100644 (file)
--- a/src/lib/ecore/ecore_idler.c
+++ b/src/lib/ecore/ecore_idler.c
@@ -31,6 +31,7 @@ ecore_idler_add(Ecore_Task_Cb func,
 {
    Ecore_Idler *ie = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!func) goto unlock;
    ie = ecore_idler_calloc(1);
@@ -49,6 +50,7 @@ ecore_idler_del(Ecore_Idler *idler)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(idler, ECORE_MAGIC_IDLER))
      {
         ECORE_MAGIC_FAIL(idler, ECORE_MAGIC_IDLER,

diff --git a/src/lib/ecore/ecore_job.c b/src/lib/ecore/ecore_job.c
index ac27c7a..cb5a554 100644 (file)
--- a/src/lib/ecore/ecore_job.c
+++ b/src/lib/ecore/ecore_job.c
@@ -60,6 +60,7 @@ ecore_job_add(Ecore_Cb    func,
 {
    Ecore_Job *job;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!func) return NULL;
 
    job = ecore_job_calloc(1);
@@ -86,6 +87,7 @@ ecore_job_del(Ecore_Job *job)
 {
    void *data;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(job, ECORE_MAGIC_JOB))
      {
         ECORE_MAGIC_FAIL(job, ECORE_MAGIC_JOB,

diff --git a/src/lib/ecore/ecore_main.c b/src/lib/ecore/ecore_main.c
index 587c83b..95db03d 100644 (file)
--- a/src/lib/ecore/ecore_main.c
+++ b/src/lib/ecore/ecore_main.c
@@ -856,6 +856,7 @@ _ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
 EAPI int
 ecore_main_loop_iterate_may_block(int may_block)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
 #ifndef USE_G_MAIN_LOOP
    _ecore_lock();
 in_main_loop++;
@@ -870,6 +871,7 @@ in_main_loop--;
 EAPI void
 ecore_main_loop_iterate(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
 #ifndef USE_G_MAIN_LOOP
    _ecore_lock();
    _ecore_main_loop_iterate_internal(1);
@@ -900,6 +902,7 @@ ecore_main_loop_iterate(void)
 EAPI void
 ecore_main_loop_begin(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
 #ifndef USE_G_MAIN_LOOP
    _ecore_lock();
    in_main_loop++;
@@ -928,6 +931,7 @@ ecore_main_loop_begin(void)
 EAPI void
 ecore_main_loop_quit(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    do_quit = 1;
 #ifdef USE_G_MAIN_LOOP
    if (ecore_main_loop)
@@ -950,6 +954,7 @@ ecore_main_loop_quit(void)
 EAPI void
 ecore_main_loop_select_func_set(Ecore_Select_Function func)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    main_loop_select = func;
 }
 
@@ -961,6 +966,7 @@ ecore_main_loop_select_func_set(Ecore_Select_Function func)
 EAPI Ecore_Select_Function
 ecore_main_loop_select_func_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    return main_loop_select;
 }
 
@@ -974,6 +980,7 @@ ecore_main_fd_handler_add(int                    fd,
 {
    Ecore_Fd_Handler *fdh = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if ((fd < 0) || (flags == 0) || (!func)) goto unlock;
@@ -1019,6 +1026,7 @@ ecore_main_win32_handler_add(void                 *h,
 {
    Ecore_Win32_Handler *wh;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!h || !func) return NULL;
 
    wh = ecore_win32_handler_calloc(1);
@@ -1050,6 +1058,7 @@ ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
 {
    void *ret = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
@@ -1068,6 +1077,7 @@ unlock:
 EAPI void *
 ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(win32_handler, ECORE_MAGIC_WIN32_HANDLER))
      {
         ECORE_MAGIC_FAIL(win32_handler, ECORE_MAGIC_WIN32_HANDLER,
@@ -1093,6 +1103,7 @@ ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler,
                                            Ecore_Fd_Prep_Cb  func,
                                            const void       *data)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
@@ -1116,6 +1127,7 @@ ecore_main_fd_handler_fd_get(Ecore_Fd_Handler *fd_handler)
 {
    int fd = -1;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(-1);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
@@ -1136,6 +1148,7 @@ ecore_main_fd_handler_active_get(Ecore_Fd_Handler      *fd_handler,
 {
    int ret = EINA_FALSE;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
@@ -1158,6 +1171,7 @@ ecore_main_fd_handler_active_set(Ecore_Fd_Handler      *fd_handler,
 {
    int ret;
 
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))

diff --git a/src/lib/ecore/ecore_pipe.c b/src/lib/ecore/ecore_pipe.c
index ea7453e..eb4a1dc 100644 (file)
--- a/src/lib/ecore/ecore_pipe.c
+++ b/src/lib/ecore/ecore_pipe.c
@@ -125,6 +125,7 @@ ecore_pipe_add(Ecore_Pipe_Cb handler,
    Ecore_Pipe *p;
    int fds[2];
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!handler) return NULL;
 
    p = ecore_pipe_calloc(1);
@@ -162,6 +163,7 @@ ecore_pipe_del(Ecore_Pipe *p)
 {
    void *data;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
      {
         ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_del");
@@ -185,6 +187,7 @@ ecore_pipe_del(Ecore_Pipe *p)
 EAPI void
 ecore_pipe_read_close(Ecore_Pipe *p)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
      {
         ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_read_close");
@@ -212,6 +215,7 @@ ecore_pipe_read_close(Ecore_Pipe *p)
 EAPI void
 ecore_pipe_freeze(Ecore_Pipe *p)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
      {
         ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_read_freeze");
@@ -235,6 +239,7 @@ ecore_pipe_freeze(Ecore_Pipe *p)
 EAPI void
 ecore_pipe_thaw(Ecore_Pipe *p)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
      {
         ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_read_thaw");
@@ -273,6 +278,7 @@ ecore_pipe_wait(Ecore_Pipe *p,
    int ret;
    int total = 0;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(-1);
    if (p->fd_read == PIPE_FD_INVALID)
      return -1;
 
@@ -280,7 +286,7 @@ ecore_pipe_wait(Ecore_Pipe *p,
    FD_SET(p->fd_read, &rset);
 
    if (wait >= 0.0)
-     end = ecore_time_get() + wait;
+     end = ecore_loop_time_get() + wait;
    timeout = wait;
 
    while (message_count > 0 && (timeout > 0.0 || wait <= 0.0))
@@ -335,7 +341,7 @@ ecore_pipe_wait(Ecore_Pipe *p,
           }
 
         if (wait >= 0.0)
-          timeout = end - ecore_time_get();
+          timeout = end - ecore_loop_time_get();
      }
 
    return total;

diff --git a/src/lib/ecore/ecore_poll.c b/src/lib/ecore/ecore_poll.c
index bf4da6a..149b3d4 100644 (file)
--- a/src/lib/ecore/ecore_poll.c
+++ b/src/lib/ecore/ecore_poll.c
@@ -193,6 +193,7 @@ EAPI void
 ecore_poller_poll_interval_set(Ecore_Poller_Type type __UNUSED__,
                                double            poll_time)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    poll_interval = poll_time;
    _ecore_poller_next_tick_eval();
 }
@@ -200,6 +201,7 @@ ecore_poller_poll_interval_set(Ecore_Poller_Type type __UNUSED__,
 EAPI double
 ecore_poller_poll_interval_get(Ecore_Poller_Type type __UNUSED__)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    return poll_interval;
 }
 
@@ -212,6 +214,7 @@ ecore_poller_add(Ecore_Poller_Type type __UNUSED__,
    Ecore_Poller *poller;
    int ibit;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!func) return NULL;
    if (interval < 1) interval = 1;
 
@@ -246,6 +249,7 @@ ecore_poller_poller_interval_set(Ecore_Poller *poller,
 {
    int ibit;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
    if (!ECORE_MAGIC_CHECK(poller, ECORE_MAGIC_POLLER))
      {
         ECORE_MAGIC_FAIL(poller, ECORE_MAGIC_POLLER,
@@ -281,6 +285,7 @@ ecore_poller_poller_interval_get(Ecore_Poller *poller)
 {
    int ibit, interval = 1;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    if (!ECORE_MAGIC_CHECK(poller, ECORE_MAGIC_POLLER))
      {
         ECORE_MAGIC_FAIL(poller, ECORE_MAGIC_POLLER,
@@ -302,6 +307,7 @@ ecore_poller_del(Ecore_Poller *poller)
 {
    void *data;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    if (!ECORE_MAGIC_CHECK(poller, ECORE_MAGIC_POLLER))
      {
         ECORE_MAGIC_FAIL(poller, ECORE_MAGIC_POLLER,

diff --git a/src/lib/ecore/ecore_thread.c b/src/lib/ecore/ecore_thread.c
index 85fbe64..29d92a4 100644 (file)
--- a/src/lib/ecore/ecore_thread.c
+++ b/src/lib/ecore/ecore_thread.c
@@ -265,7 +265,7 @@ _ecore_thread_worker_free(Ecore_Pthread_Worker *worker)
    CDD(worker->cond);
    LKD(worker->mutex);
 
-   if (_ecore_thread_worker_count > (_ecore_thread_count_max + 1) * 16)
+   if (_ecore_thread_worker_count > ((_ecore_thread_count_max + 1) * 16))
      {
         free(worker);
         return;
@@ -762,6 +762,8 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking,
    Ecore_Pthread_Data *pth = NULL;
 #endif
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
+   
    if (!func_blocking) return NULL;
 
    work = _ecore_thread_worker_new();
@@ -975,6 +977,8 @@ ecore_thread_feedback_run(Ecore_Thread_Cb        func_heavy,
    Ecore_Pthread_Worker *worker;
    Ecore_Pthread_Data *pth = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
+   
    if (!func_heavy) return NULL;
 
    worker = _ecore_thread_worker_new();
@@ -1251,6 +1255,7 @@ EAPI int
 ecore_thread_active_get(void)
 {
 #ifdef EFL_HAVE_THREADS
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    return _ecore_thread_count;
 #else
    return 0;
@@ -1263,6 +1268,7 @@ ecore_thread_pending_get(void)
 #ifdef EFL_HAVE_THREADS
    int ret;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    LKL(_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads);
    LKU(_ecore_pending_job_threads_mutex);
@@ -1278,6 +1284,7 @@ ecore_thread_pending_feedback_get(void)
 #ifdef EFL_HAVE_THREADS
    int ret;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    LKL(_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads_feedback);
    LKU(_ecore_pending_job_threads_mutex);
@@ -1293,6 +1300,7 @@ ecore_thread_pending_total_get(void)
 #ifdef EFL_HAVE_THREADS
    int ret;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    LKL(_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_feedback);
    LKU(_ecore_pending_job_threads_mutex);
@@ -1305,12 +1313,14 @@ ecore_thread_pending_total_get(void)
 EAPI int
 ecore_thread_max_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    return _ecore_thread_count_max;
 }
 
 EAPI void
 ecore_thread_max_set(int num)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (num < 1) return;
    /* avoid doing something hilarious by blocking dumb users */
    if (num >= (2 * eina_cpu_count())) return;
@@ -1321,6 +1331,7 @@ ecore_thread_max_set(int num)
 EAPI void
 ecore_thread_max_reset(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
    _ecore_thread_count_max = eina_cpu_count();
 }
 

diff --git a/src/lib/ecore/ecore_throttle.c b/src/lib/ecore/ecore_throttle.c
index b5e3133..de0a43e 100644 (file)
--- a/src/lib/ecore/ecore_throttle.c
+++ b/src/lib/ecore/ecore_throttle.c
@@ -66,6 +66,7 @@ static int throttle_val = 0;
 EAPI void
 ecore_throttle_adjust(double amount)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    int adj = amount * 1000000.0;
    throttle_val += adj;
    if (throttle_val < 0) throttle_val = 0;
@@ -83,6 +84,7 @@ ecore_throttle_adjust(double amount)
 EAPI double
 ecore_throttle_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    return (double)throttle_val / 1000000.0;
 }
 

diff --git a/src/lib/ecore/ecore_timer.c b/src/lib/ecore/ecore_timer.c
index d76733b..45b5b81 100644 (file)
--- a/src/lib/ecore/ecore_timer.c
+++ b/src/lib/ecore/ecore_timer.c
@@ -69,6 +69,7 @@ static double precision = 10.0 / 1000000.0;
 EAPI double
 ecore_timer_precision_get(void)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    return precision;
 }
 
@@ -100,6 +101,7 @@ ecore_timer_precision_get(void)
 EAPI void
 ecore_timer_precision_set(double value)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (value < 0.0)
@@ -139,6 +141,7 @@ ecore_timer_add(double        in,
    double now;
    Ecore_Timer *timer = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    if (!func) goto unlock;
    if (in < 0.0) in = 0.0;
@@ -177,6 +180,7 @@ ecore_timer_loop_add(double        in,
 {
    Ecore_Timer *timer;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
    timer = _ecore_timer_loop_add(in, func, data);
    _ecore_unlock();
@@ -198,6 +202,7 @@ ecore_timer_del(Ecore_Timer *timer)
 {
    void *data = NULL;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -225,6 +230,7 @@ EAPI void
 ecore_timer_interval_set(Ecore_Timer *timer,
                          double       in)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -249,6 +255,7 @@ ecore_timer_interval_get(Ecore_Timer *timer)
 {
    double interval;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -276,6 +283,7 @@ EAPI void
 ecore_timer_delay(Ecore_Timer *timer,
                   double       add)
 {
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
      {
         ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
@@ -302,6 +310,7 @@ EAPI void
 ecore_timer_reset(Ecore_Timer *timer)
 {
    double now, add;
+   EINA_MAIN_LOOP_CHECK_RETURN;
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
      {
         ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
@@ -331,6 +340,7 @@ ecore_timer_pending_get(Ecore_Timer *timer)
    double now;
    double ret = 0.0;
 
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -370,6 +380,7 @@ ecore_timer_freeze(Ecore_Timer *timer)
 {
    double now;
 
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -413,6 +424,7 @@ ecore_timer_thaw(Ecore_Timer *timer)
 {
    double now;
 
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_lock();
 
    if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
@@ -445,6 +457,7 @@ ecore_timer_dump(void)
    int living_timer = 0;
    int unknow_timer = 0;
 
+   EINA_MAIN_LOOP_CHECK_RETURN(NULL);
    _ecore_lock();
    result = eina_strbuf_new();