Enlightenment

Log:
  note: '/*' is not how you begin a doxygen code block
  
Author:       discomfitor
Date:         2010-07-19 22:25:02 -0700 (Mon, 19 Jul 2010)
New Revision: 50372

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-19 20:21:57 UTC (rev 50371)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 05:25:02 UTC (rev 50372)
@@ -327,7 +327,7 @@
 #endif
 }
 
-/*
+/**
  * @brief Run some blocking code in a parrallel thread to avoid locking the main loop.
  * @param func_blocking The function that should run in another thread.
  * @param func_end The function that will be called in the main loop if the thread terminate correctly.
@@ -421,7 +421,7 @@
 #endif
 }
 
-/*
+/**
  * @brief Cancel a running thread.
  * @param thread The thread to cancel.
  * @return Will return EINA_TRUE if the thread has been cancelled,
@@ -469,7 +469,7 @@
 #endif
 }
 
-/*
+/**
  * @brief Tell if a thread was canceled or not.
  * @param thread The thread to test.
  * @return EINA_TRUE if the thread is cancelled,
@@ -486,7 +486,7 @@
    return worker->cancel;
 }
 
-/*
+/**
  * @brief Run some heavy code in a parrallel thread to avoid locking the main loop.
  * @param func_heavy The function that should run in another thread.
  * @param func_notify The function that will receive the data send by func_heavy in the main loop.
@@ -618,7 +618,7 @@
 #endif
 }
 
-/*
+/**
  * @brief Send data to main loop from worker thread.
  * @param thread The current Ecore_Thread context to send data from
  * @param data Data to be transmitted to the main loop

Log:
  +ecore_thread_active_get, ecore_thread_pending_get, ecore_thread_pending_long_get to retrieve number of threads present with given status
  
Author:       discomfitor
Date:         2010-07-20 02:40:18 -0700 (Tue, 20 Jul 2010)
New Revision: 50375

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-20 09:32:28 UTC (rev 50374)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-20 09:40:18 UTC (rev 50375)
@@ -350,7 +350,11 @@
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_check(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_notify(Ecore_Thread *thread, const void *msg_data);
+   EAPI int           ecore_thread_active_get(void);
+   EAPI int           ecore_thread_pending_get(void);
+   EAPI int           ecore_thread_pending_long_get(void);
 
+
    EAPI double ecore_time_get(void);
    EAPI double ecore_loop_time_get(void);
 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 09:32:28 UTC (rev 50374)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 09:40:18 UTC (rev 50375)
@@ -651,3 +651,50 @@
 #endif
 }
 
+/**
+ * @brief Get number of active thread jobs
+ * @return Number of active threads running jobs
+ * This returns the number of threads currently running jobs through the
+ * ecore_thread api.
+ */
+EAPI int
+ecore_thread_active_get(void)
+{
+#ifdef EFL_HAVE_PTHREAD
+   return eina_list_count(_ecore_thread);
+#else
+   return 0;
+#endif
+}
+
+/**
+ * @brief Get number of pending (short) thread jobs
+ * @return Number of pending threads running "short" jobs
+ * This returns the number of threads currently running jobs through the
+ * ecore_thread_run api call.
+ */
+EAPI int
+ecore_thread_pending_get(void)
+{
+#ifdef EFL_HAVE_PTHREAD
+   return eina_list_count(_ecore_thread_data);
+#else
+   return 0;
+#endif
+}
+
+/**
+ * @brief Get number of pending long thread jobs
+ * @return Number of pending threads running "long" jobs
+ * This returns the number of threads currently running jobs through the
+ * ecore_long_run api call.
+ */
+EAPI int
+ecore_thread_pending_long_get(void)
+{
+#ifdef EFL_HAVE_PTHREAD
+   return eina_list_count(_ecore_long_thread_data);
+#else
+   return 0;
+#endif
+}

Log:
  some variable renames to make this easier to understand
  
Author:       discomfitor
Date:         2010-07-20 02:40:53 -0700 (Tue, 20 Jul 2010)
New Revision: 50376

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 09:40:18 UTC (rev 50375)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 09:40:53 UTC (rev 50376)
@@ -59,9 +59,9 @@
 
 #ifdef EFL_HAVE_PTHREAD
 static int _ecore_thread_count = 0;
-static Eina_List *_ecore_thread = NULL;
-static Eina_List *_ecore_thread_data = NULL;
-static Eina_List *_ecore_long_thread_data = NULL;
+static Eina_List *_ecore_active_job_threads = NULL;
+static Eina_List *_ecore_pending_job_threads = NULL;
+static Eina_List *_ecore_pending_job_threads_long = NULL;
 static Ecore_Event_Handler *del_handler = NULL;
 
 static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -89,7 +89,7 @@
    if (pthread_join(pth->thread, (void **) &p) != 0)
      return ;
 
-   _ecore_thread = eina_list_remove(_ecore_thread, pth);
+   _ecore_active_job_threads = eina_list_remove(_ecore_active_job_threads, pth);
 
    ecore_event_add(ECORE_THREAD_PIPE_DEL, pth->p, _ecore_thread_pipe_free, NULL);
 }
@@ -137,18 +137,18 @@
 {
    Ecore_Pthread_Worker *work;
 
-   while (_ecore_thread_data)
+   while (_ecore_pending_job_threads)
      {
 	pthread_mutex_lock(&_mutex);
 
-	if (!_ecore_thread_data)
+	if (!_ecore_pending_job_threads)
 	  {
 	     pthread_mutex_unlock(&_mutex);
 	     break;
 	  }
 
-	work = eina_list_data_get(_ecore_thread_data);
-	_ecore_thread_data = eina_list_remove_list(_ecore_thread_data, _ecore_thread_data);
+	work = eina_list_data_get(_ecore_pending_job_threads);
+	_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
 
 	pthread_mutex_unlock(&_mutex);
 
@@ -163,18 +163,18 @@
 {
    Ecore_Pthread_Worker *work;
 
-   while (_ecore_long_thread_data)
+   while (_ecore_pending_job_threads_long)
      {
 	pthread_mutex_lock(&_mutex);
 
-	if (!_ecore_long_thread_data)
+	if (!_ecore_pending_job_threads_long)
 	  {
 	     pthread_mutex_unlock(&_mutex);
 	     break;
 	  }
 
-	work = eina_list_data_get(_ecore_long_thread_data);
-	_ecore_long_thread_data = eina_list_remove_list(_ecore_long_thread_data, _ecore_long_thread_data);
+	work = eina_list_data_get(_ecore_pending_job_threads_long);
+	_ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
 
 	pthread_mutex_unlock(&_mutex);
 
@@ -242,18 +242,18 @@
    pthread_mutex_unlock(&_mutex);
 
  on_error:
-   if (_ecore_thread_data) _ecore_short_job(pth->p);
-   if (_ecore_long_thread_data) _ecore_long_job(pth->p, pth->thread);
+   if (_ecore_pending_job_threads) _ecore_short_job(pth->p);
+   if (_ecore_pending_job_threads_long) _ecore_long_job(pth->p, pth->thread);
 
    /* FIXME: Check if there is long running task todo, and switch to long run handler. */
 
    pthread_mutex_lock(&_mutex);
-   if (_ecore_thread_data)
+   if (_ecore_pending_job_threads)
      {
 	pthread_mutex_unlock(&_mutex);
 	goto on_error;
      }
-   if (_ecore_long_thread_data)
+   if (_ecore_pending_job_threads_long)
      {
 	pthread_mutex_unlock(&_mutex);
 	goto on_error;
@@ -303,7 +303,7 @@
 
    pthread_mutex_lock(&_mutex);
 
-   EINA_LIST_FREE(_ecore_thread_data, work)
+   EINA_LIST_FREE(_ecore_pending_job_threads, work)
      {
 	if (work->func_cancel)
 	  work->func_cancel((void *)work->data);
@@ -312,7 +312,7 @@
 
    pthread_mutex_unlock(&_mutex);
 
-   EINA_LIST_FREE(_ecore_thread, pth)
+   EINA_LIST_FREE(_ecore_active_job_threads, pth)
      {
 	Ecore_Pipe *p;
 
@@ -374,7 +374,7 @@
    work->data = data;
 
    pthread_mutex_lock(&_mutex);
-   _ecore_thread_data = eina_list_append(_ecore_thread_data, work);
+   _ecore_pending_job_threads = eina_list_append(_ecore_pending_job_threads, work);
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
@@ -445,10 +445,10 @@
 
    pthread_mutex_lock(&_mutex);
 
-   EINA_LIST_FOREACH(_ecore_thread_data, l, work)
+   EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)
      if ((void *) work == (void *) thread)
        {
-	  _ecore_thread_data = eina_list_remove_list(_ecore_thread_data, l);
+	  _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
 
 	  pthread_mutex_unlock(&_mutex);
 
@@ -551,7 +551,7 @@
      }
 
    pthread_mutex_lock(&_mutex);
-   _ecore_long_thread_data = eina_list_append(_ecore_long_thread_data, worker);
+   _ecore_pending_job_threads_long = eina_list_append(_ecore_pending_job_threads_long, worker);
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
@@ -661,7 +661,7 @@
 ecore_thread_active_get(void)
 {
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_thread);
+   return eina_list_count(_ecore_active_job_threads);
 #else
    return 0;
 #endif
@@ -677,7 +677,7 @@
 ecore_thread_pending_get(void)
 {
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_thread_data);
+   return eina_list_count(_ecore_pending_job_threads);
 #else
    return 0;
 #endif
@@ -693,7 +693,7 @@
 ecore_thread_pending_long_get(void)
 {
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_long_thread_data);
+   return eina_list_count(_ecore_pending_job_threads_long);
 #else
    return 0;
 #endif

Log:
  +ecore_thread_max_{set,get} to return/set the max number of threads ecore will attempt to run simultaneously
  
Author:       discomfitor
Date:         2010-07-20 18:04:28 -0700 (Tue, 20 Jul 2010)
New Revision: 50397

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-20 22:09:35 UTC (rev 50396)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 01:04:28 UTC (rev 50397)
@@ -353,6 +353,8 @@
    EAPI int           ecore_thread_active_get(void);
    EAPI int           ecore_thread_pending_get(void);
    EAPI int           ecore_thread_pending_long_get(void);
+   EAPI int           ecore_thread_max_get(void);
+   EAPI void          ecore_thread_max_set(int num);
 
 
    EAPI double ecore_time_get(void);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-20 22:09:35 UTC (rev 50396)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 01:04:28 UTC (rev 50397)
@@ -326,6 +326,10 @@
    del_handler = NULL;
 #endif
 }
+/**
+ * @defgroup Ecore_Thread Ecore Thread Functions
+ * These functions allow for ecore-managed threads which integrate with ecore's main loop.
+	*/
 
 /**
  * @brief Run some blocking code in a parrallel thread to avoid locking the main loop.
@@ -698,3 +702,32 @@
    return 0;
 #endif
 }
+
+
+/**
+ * @brief Get the max number of threads that can run simultaneously
+ * @return Max number of threads ecore will run
+ * This returns the total number of threads that ecore will attempt to run
+ * simultaneously.
+ */
+EAPI int
+ecore_thread_max_get(void)
+{
+	  return _ecore_thread_count_max;
+}
+
+/**
+ * @brief Set the max number of threads that can run simultaneously
+ * @param num The new maximum
+ * This sets the maximum number of threads that ecore will try to run
+ * simultaneously.  This number cannot be < 1 or >= 2x the number of active cpus.
+ */
+EAPI void
+ecore_thread_max_set(int num)
+{
+   if (num < 1) return;
+   /* avoid doing something hilarious by blocking dumb users */
+   if (num >= (2 * eina_cpu_count())) return;
+
+   _ecore_thread_count_max = num;
+}

Log:
  +ecore_thread_max_reset, ecore_thread_avail_get for more thread functionality, also fix formatting
  
Author:       discomfitor
Date:         2010-07-20 19:12:10 -0700 (Tue, 20 Jul 2010)
New Revision: 50399

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 01:37:07 UTC (rev 50398)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 02:12:10 UTC (rev 50399)
@@ -355,6 +355,8 @@
    EAPI int           ecore_thread_pending_long_get(void);
    EAPI int           ecore_thread_max_get(void);
    EAPI void          ecore_thread_max_set(int num);
+   EAPI void          ecore_thread_max_reset(void);
+   EAPI int           ecore_thread_avail_get(void);
 
 
    EAPI double ecore_time_get(void);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 01:37:07 UTC (rev 50398)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 02:12:10 UTC (rev 50399)
@@ -105,13 +105,13 @@
 
    if (work->cancel)
      {
-	if (work->func_cancel)
-	  work->func_cancel((void *) work->data);
+								if (work->func_cancel)
+										work->func_cancel((void *) work->data);
      }
    else
      {
-	if (work->func_end)
-	  work->func_end((void *) work->data);
+								if (work->func_end)
+										work->func_end((void *) work->data);
      }
 
    if (work->long_run) ecore_pipe_del(work->u.long_run.notify);
@@ -139,22 +139,22 @@
 
    while (_ecore_pending_job_threads)
      {
-	pthread_mutex_lock(&_mutex);
+								pthread_mutex_lock(&_mutex);
 
-	if (!_ecore_pending_job_threads)
-	  {
-	     pthread_mutex_unlock(&_mutex);
-	     break;
-	  }
+								if (!_ecore_pending_job_threads)
+										{
+													pthread_mutex_unlock(&_mutex);
+													break;
+										}
 
-	work = eina_list_data_get(_ecore_pending_job_threads);
-	_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
+								work = eina_list_data_get(_ecore_pending_job_threads);
+								_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
 
-	pthread_mutex_unlock(&_mutex);
+								pthread_mutex_unlock(&_mutex);
 
-	work->u.short_run.func_blocking((void *) work->data);
+								work->u.short_run.func_blocking((void *) work->data);
 
-	ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+								ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
      }
 }
 
@@ -165,23 +165,23 @@
 
    while (_ecore_pending_job_threads_long)
      {
-	pthread_mutex_lock(&_mutex);
+								pthread_mutex_lock(&_mutex);
 
-	if (!_ecore_pending_job_threads_long)
-	  {
-	     pthread_mutex_unlock(&_mutex);
-	     break;
-	  }
+								if (!_ecore_pending_job_threads_long)
+										{
+													pthread_mutex_unlock(&_mutex);
+													break;
+										}
 
-	work = eina_list_data_get(_ecore_pending_job_threads_long);
-	_ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
+								work = eina_list_data_get(_ecore_pending_job_threads_long);
+								_ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
 
-	pthread_mutex_unlock(&_mutex);
+								pthread_mutex_unlock(&_mutex);
 
-	work->u.long_run.self = thread;
-	work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
+								work->u.long_run.self = thread;
+								work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
 
-	ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+								ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
      }
 }
 
@@ -199,8 +199,8 @@
    pth->p = ecore_pipe_add(_ecore_thread_handler, NULL);
    if (!pth->p)
      {
-	free(pth);
-	return NULL;
+						 	free(pth);
+							 return NULL;
      }
    pth->thread = pthread_self();
 
@@ -212,9 +212,9 @@
    work = malloc(sizeof (Ecore_Pthread_Worker));
    if (!work)
      {
-	ecore_pipe_del(pth->p);
-	free(pth);
-	return NULL;
+								ecore_pipe_del(pth->p);
+								free(pth);
+								return NULL;
      }
 
    work->data = pth;
@@ -250,13 +250,13 @@
    pthread_mutex_lock(&_mutex);
    if (_ecore_pending_job_threads)
      {
-	pthread_mutex_unlock(&_mutex);
-	goto on_error;
+								pthread_mutex_unlock(&_mutex);
+								goto on_error;
      }
    if (_ecore_pending_job_threads_long)
      {
-	pthread_mutex_unlock(&_mutex);
-	goto on_error;
+								pthread_mutex_unlock(&_mutex);
+								goto on_error;
      }
 
    _ecore_thread_count--;
@@ -305,21 +305,21 @@
 
    EINA_LIST_FREE(_ecore_pending_job_threads, work)
      {
-	if (work->func_cancel)
-	  work->func_cancel((void *)work->data);
-	free(work);
+								if (work->func_cancel)
+										work->func_cancel((void *)work->data);
+								free(work);
      }
 
    pthread_mutex_unlock(&_mutex);
 
    EINA_LIST_FREE(_ecore_active_job_threads, pth)
      {
-	Ecore_Pipe *p;
+								Ecore_Pipe *p;
 
-	pthread_cancel(pth->thread);
-	pthread_join(pth->thread, (void **) &p);
+								pthread_cancel(pth->thread);
+								pthread_join(pth->thread, (void **) &p);
 
-	ecore_pipe_del(pth->p);
+								ecore_pipe_del(pth->p);
      }
 
    ecore_event_handler_del(del_handler);
@@ -367,7 +367,7 @@
    if (!work)
      {
         func_cancel((void *) data);
-	return NULL;
+	       return NULL;
      }
 
    work->u.short_run.func_blocking = func_blocking;
@@ -382,8 +382,8 @@
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-	pthread_mutex_unlock(&_mutex);
-	return (Ecore_Thread *) work;
+								pthread_mutex_unlock(&_mutex);
+								return (Ecore_Thread *) work;
      }
 
    pthread_mutex_unlock(&_mutex);
@@ -401,16 +401,16 @@
  on_error:
    if (pth)
      {
-	if (pth->p) ecore_pipe_del(pth->p);
-	free(pth);
+								if (pth->p) ecore_pipe_del(pth->p);
+								free(pth);
      }
 
    if (_ecore_thread_count == 0)
      {
-	if (work->func_cancel)
-	  work->func_cancel((void *) work->data);
-	free(work);
-	work = NULL;
+								if (work->func_cancel)
+										work->func_cancel((void *) work->data);
+								free(work);
+								work = NULL;
      }
    return (Ecore_Thread *) work;
 #else
@@ -452,15 +452,15 @@
    EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)
      if ((void *) work == (void *) thread)
        {
-	  _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
+									_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
 
-	  pthread_mutex_unlock(&_mutex);
+									pthread_mutex_unlock(&_mutex);
 
-	  if (work->func_cancel)
-	    work->func_cancel((void *) work->data);
-	  free(work);
+									if (work->func_cancel)
+											work->func_cancel((void *) work->data);
+									free(work);
 
-	  return EINA_TRUE;
+									return EINA_TRUE;
        }
 
    pthread_mutex_unlock(&_mutex);
@@ -548,10 +548,10 @@
 
    if (!try_no_queue)
      {
-	pthread_t t;
+								pthread_t t;
 
-	if (pthread_create(&t, NULL, (void *) _ecore_direct_worker, worker) == 0)
-	  return (Ecore_Thread *) worker;
+								if (pthread_create(&t, NULL, (void *) _ecore_direct_worker, worker) == 0)
+										return (Ecore_Thread *) worker;
      }
 
    pthread_mutex_lock(&_mutex);
@@ -559,8 +559,8 @@
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-	pthread_mutex_unlock(&_mutex);
-	return (Ecore_Thread *) worker;
+								pthread_mutex_unlock(&_mutex);
+								return (Ecore_Thread *) worker;
      }
 
    pthread_mutex_unlock(&_mutex);
@@ -578,20 +578,20 @@
  on_error:
    if (pth)
      {
-	if (pth->p) ecore_pipe_del(pth->p);
-	free(pth);
+								if (pth->p) ecore_pipe_del(pth->p);
+								free(pth);
      }
 
    if (_ecore_thread_count == 0)
      {
-	if (func_cancel) func_cancel((void *) data);
+								if (func_cancel) func_cancel((void *) data);
 
-	if (worker)
-	  {
-	     ecore_pipe_del(worker->u.long_run.notify);
-	     free(worker);
-	     worker = NULL;
-	  }
+								if (worker)
+										{
+													ecore_pipe_del(worker->u.long_run.notify);
+													free(worker);
+													worker = NULL;
+										}
      }
 
    return (Ecore_Thread *) worker;
@@ -731,3 +731,31 @@
 
    _ecore_thread_count_max = num;
 }
+
+/**
+ * @brief Reset the max number of threads that can run simultaneously
+ * This resets the maximum number of threads that ecore will try to run
+ * simultaneously to the number of active cpus.
+ */
+EAPI void
+ecore_thread_max_reset(void)
+{
+   _ecore_thread_count_max = eina_cpu_count();
+}
+
+/**
+ * @brief Get the number of threads which are available to be used
+ * @return The number of available threads
+ * This returns the number of threads slots that ecore has currently available.
+ * Assuming that you haven't changed the max number of threads with @ref ecore_thread_max_set
+ * this should be equal to (num_cpus - (active_running + active_long_running))
+ */
+EAPI int
+ecore_thread_avail_get(void)
+{
+#ifdef EFL_HAVE_PTHREAD
+   return _ecore_thread_count_max - (eina_list_count(_ecore_pending_job_threads_long) + eina_list_count(_ecore_pending_job_threads));
+#else
+   return 0;
+#endif
+}

Log:
  +ecore_thread_total_get to return total number of pending jobs
  
Author:       discomfitor
Date:         2010-07-20 21:03:40 -0700 (Tue, 20 Jul 2010)
New Revision: 50405

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 03:59:37 UTC (rev 50404)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 04:03:40 UTC (rev 50405)
@@ -353,6 +353,7 @@
    EAPI int           ecore_thread_active_get(void);
    EAPI int           ecore_thread_pending_get(void);
    EAPI int           ecore_thread_pending_long_get(void);
+   EAPI int           ecore_thread_pending_total_get(void);
    EAPI int           ecore_thread_max_get(void);
    EAPI void          ecore_thread_max_set(int num);
    EAPI void          ecore_thread_max_reset(void);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 03:59:37 UTC (rev 50404)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 04:03:40 UTC (rev 50405)
@@ -703,6 +703,21 @@
 #endif
 }
 
+/**
+ * @brief Get number of pending thread jobs
+ * @return Number of pending threads running jobs
+ * This returns the number of threads currently running jobs through the
+ * ecore_thread_run and ecore_long_run api calls combined.
+ */
+EAPI int
+ecore_thread_pending_total_get(void)
+{
+#ifdef EFL_HAVE_PTHREAD
+   return eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_long);
+#else
+   return 0;
+#endif
+}
 
 /**
  * @brief Get the max number of threads that can run simultaneously

Log:
  man I fail at formatting
  
Author:       discomfitor
Date:         2010-07-20 21:26:57 -0700 (Tue, 20 Jul 2010)
New Revision: 50406

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 04:03:40 UTC (rev 50405)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 04:26:57 UTC (rev 50406)
@@ -20,16 +20,16 @@
 {
    union {
       struct {
-	 void (*func_blocking)(void *data);
+  void (*func_blocking)(void *data);
       } short_run;
       struct {
-	 void (*func_heavy)(Ecore_Thread *thread, void *data);
-	 void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
+  void (*func_heavy)(Ecore_Thread *thread, void *data);
+  void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
 
-	 Ecore_Pipe *notify;
+  Ecore_Pipe *notify;
 
 #ifdef EFL_HAVE_PTHREAD
-	 pthread_t self;
+  pthread_t self;
 #endif
       } long_run;
    } u;
@@ -105,13 +105,13 @@
 
    if (work->cancel)
      {
-								if (work->func_cancel)
-										work->func_cancel((void *) work->data);
+        if (work->func_cancel)
+          work->func_cancel((void *) work->data);
      }
    else
      {
-								if (work->func_end)
-										work->func_end((void *) work->data);
+        if (work->func_end)
+          work->func_end((void *) work->data);
      }
 
    if (work->long_run) ecore_pipe_del(work->u.long_run.notify);
@@ -139,22 +139,22 @@
 
    while (_ecore_pending_job_threads)
      {
-								pthread_mutex_lock(&_mutex);
+        pthread_mutex_lock(&_mutex);
 
-								if (!_ecore_pending_job_threads)
-										{
-													pthread_mutex_unlock(&_mutex);
-													break;
-										}
+        if (!_ecore_pending_job_threads)
+          {
+             pthread_mutex_unlock(&_mutex);
+             break;
+          }
 
-								work = eina_list_data_get(_ecore_pending_job_threads);
-								_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
+        work = eina_list_data_get(_ecore_pending_job_threads);
+        _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
 
-								pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_mutex);
 
-								work->u.short_run.func_blocking((void *) work->data);
+        work->u.short_run.func_blocking((void *) work->data);
 
-								ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+        ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
      }
 }
 
@@ -165,23 +165,23 @@
 
    while (_ecore_pending_job_threads_long)
      {
-								pthread_mutex_lock(&_mutex);
+        pthread_mutex_lock(&_mutex);
 
-								if (!_ecore_pending_job_threads_long)
-										{
-													pthread_mutex_unlock(&_mutex);
-													break;
-										}
+        if (!_ecore_pending_job_threads_long)
+          {
+             pthread_mutex_unlock(&_mutex);
+             break;
+          }
 
-								work = eina_list_data_get(_ecore_pending_job_threads_long);
-								_ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
+        work = eina_list_data_get(_ecore_pending_job_threads_long);
+        _ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
 
-								pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_mutex);
 
-								work->u.long_run.self = thread;
-								work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
+        work->u.long_run.self = thread;
+        work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
 
-								ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
+        ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
      }
 }
 
@@ -199,8 +199,8 @@
    pth->p = ecore_pipe_add(_ecore_thread_handler, NULL);
    if (!pth->p)
      {
-						 	free(pth);
-							 return NULL;
+        free(pth);
+        return NULL;
      }
    pth->thread = pthread_self();
 
@@ -212,9 +212,9 @@
    work = malloc(sizeof (Ecore_Pthread_Worker));
    if (!work)
      {
-								ecore_pipe_del(pth->p);
-								free(pth);
-								return NULL;
+        ecore_pipe_del(pth->p);
+        free(pth);
+        return NULL;
      }
 
    work->data = pth;
@@ -250,13 +250,13 @@
    pthread_mutex_lock(&_mutex);
    if (_ecore_pending_job_threads)
      {
-								pthread_mutex_unlock(&_mutex);
-								goto on_error;
+        pthread_mutex_unlock(&_mutex);
+        goto on_error;
      }
    if (_ecore_pending_job_threads_long)
      {
-								pthread_mutex_unlock(&_mutex);
-								goto on_error;
+        pthread_mutex_unlock(&_mutex);
+        goto on_error;
      }
 
    _ecore_thread_count--;
@@ -305,21 +305,21 @@
 
    EINA_LIST_FREE(_ecore_pending_job_threads, work)
      {
-								if (work->func_cancel)
-										work->func_cancel((void *)work->data);
-								free(work);
+        if (work->func_cancel)
+          work->func_cancel((void *)work->data);
+        free(work);
      }
 
    pthread_mutex_unlock(&_mutex);
 
    EINA_LIST_FREE(_ecore_active_job_threads, pth)
      {
-								Ecore_Pipe *p;
+        Ecore_Pipe *p;
 
-								pthread_cancel(pth->thread);
-								pthread_join(pth->thread, (void **) &p);
+        pthread_cancel(pth->thread);
+        pthread_join(pth->thread, (void **) &p);
 
-								ecore_pipe_del(pth->p);
+        ecore_pipe_del(pth->p);
      }
 
    ecore_event_handler_del(del_handler);
@@ -329,7 +329,7 @@
 /**
  * @defgroup Ecore_Thread Ecore Thread Functions
  * These functions allow for ecore-managed threads which integrate with ecore's main loop.
-	*/
+ */
 
 /**
  * @brief Run some blocking code in a parrallel thread to avoid locking the main loop.
@@ -353,9 +353,9 @@
  */
 EAPI Ecore_Thread *
 ecore_thread_run(void (*func_blocking)(void *data),
-		 void (*func_end)(void *data),
-		 void (*func_cancel)(void *data),
-		 const void *data)
+   void (*func_end)(void *data),
+   void (*func_cancel)(void *data),
+   const void *data)
 {
 #ifdef EFL_HAVE_PTHREAD
    Ecore_Pthread_Worker *work;
@@ -367,7 +367,7 @@
    if (!work)
      {
         func_cancel((void *) data);
-	       return NULL;
+        return NULL;
      }
 
    work->u.short_run.func_blocking = func_blocking;
@@ -382,8 +382,8 @@
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-								pthread_mutex_unlock(&_mutex);
-								return (Ecore_Thread *) work;
+        pthread_mutex_unlock(&_mutex);
+        return (Ecore_Thread *) work;
      }
 
    pthread_mutex_unlock(&_mutex);
@@ -401,16 +401,16 @@
  on_error:
    if (pth)
      {
-								if (pth->p) ecore_pipe_del(pth->p);
-								free(pth);
+        if (pth->p) ecore_pipe_del(pth->p);
+        free(pth);
      }
 
    if (_ecore_thread_count == 0)
      {
-								if (work->func_cancel)
-										work->func_cancel((void *) work->data);
-								free(work);
-								work = NULL;
+        if (work->func_cancel)
+          work->func_cancel((void *) work->data);
+        free(work);
+        work = NULL;
      }
    return (Ecore_Thread *) work;
 #else
@@ -452,15 +452,15 @@
    EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)
      if ((void *) work == (void *) thread)
        {
-									_ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
+         _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
 
-									pthread_mutex_unlock(&_mutex);
+         pthread_mutex_unlock(&_mutex);
 
-									if (work->func_cancel)
-											work->func_cancel((void *) work->data);
-									free(work);
+         if (work->func_cancel)
+           work->func_cancel((void *) work->data);
+         free(work);
 
-									return EINA_TRUE;
+         return EINA_TRUE;
        }
 
    pthread_mutex_unlock(&_mutex);
@@ -520,11 +520,11 @@
  */
 EAPI Ecore_Thread *
 ecore_long_run(void (*func_heavy)(Ecore_Thread *thread, void *data),
-	       void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data),
-	       void (*func_end)(void *data),
-	       void (*func_cancel)(void *data),
-	       const void *data,
-	       Eina_Bool try_no_queue)
+        void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data),
+        void (*func_end)(void *data),
+        void (*func_cancel)(void *data),
+        const void *data,
+        Eina_Bool try_no_queue)
 {
 
 #ifdef EFL_HAVE_PTHREAD
@@ -548,10 +548,10 @@
 
    if (!try_no_queue)
      {
-								pthread_t t;
+        pthread_t t;
 
-								if (pthread_create(&t, NULL, (void *) _ecore_direct_worker, worker) == 0)
-										return (Ecore_Thread *) worker;
+        if (pthread_create(&t, NULL, (void *) _ecore_direct_worker, worker) == 0)
+          return (Ecore_Thread *) worker;
      }
 
    pthread_mutex_lock(&_mutex);
@@ -559,8 +559,8 @@
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-								pthread_mutex_unlock(&_mutex);
-								return (Ecore_Thread *) worker;
+        pthread_mutex_unlock(&_mutex);
+        return (Ecore_Thread *) worker;
      }
 
    pthread_mutex_unlock(&_mutex);
@@ -578,20 +578,20 @@
  on_error:
    if (pth)
      {
-								if (pth->p) ecore_pipe_del(pth->p);
-								free(pth);
+        if (pth->p) ecore_pipe_del(pth->p);
+        free(pth);
      }
 
    if (_ecore_thread_count == 0)
      {
-								if (func_cancel) func_cancel((void *) data);
+        if (func_cancel) func_cancel((void *) data);
 
-								if (worker)
-										{
-													ecore_pipe_del(worker->u.long_run.notify);
-													free(worker);
-													worker = NULL;
-										}
+        if (worker)
+          {
+             ecore_pipe_del(worker->u.long_run.notify);
+             free(worker);
+             worker = NULL;
+          }
      }
 
    return (Ecore_Thread *) worker;
@@ -728,7 +728,7 @@
 EAPI int
 ecore_thread_max_get(void)
 {
-	  return _ecore_thread_count_max;
+   return _ecore_thread_count_max;
 }
 
 /**

Log:
  fix some function variables and a cedric-requested rename
  
Author:       discomfitor
Date:         2010-07-21 00:09:51 -0700 (Wed, 21 Jul 2010)
New Revision: 50409

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 06:43:47 UTC (rev 50408)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-21 07:09:51 UTC (rev 50409)
@@ -357,7 +357,7 @@
    EAPI int           ecore_thread_max_get(void);
    EAPI void          ecore_thread_max_set(int num);
    EAPI void          ecore_thread_max_reset(void);
-   EAPI int           ecore_thread_avail_get(void);
+   EAPI int           ecore_thread_available_get(void);
 
 
    EAPI double ecore_time_get(void);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 06:43:47 UTC (rev 50408)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 07:09:51 UTC (rev 50409)
@@ -665,7 +665,7 @@
 ecore_thread_active_get(void)
 {
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_active_job_threads);
+   return _ecore_thread_count;
 #else
    return 0;
 #endif
@@ -766,10 +766,10 @@
  * this should be equal to (num_cpus - (active_running + active_long_running))
  */
 EAPI int
-ecore_thread_avail_get(void)
+ecore_thread_available_get(void)
 {
 #ifdef EFL_HAVE_PTHREAD
-   return _ecore_thread_count_max - (eina_list_count(_ecore_pending_job_threads_long) + eina_list_count(_ecore_pending_job_threads));
+   return _ecore_thread_count_max - _ecore_thread_count);
 #else
    return 0;
 #endif

Log:
  should probably make thread functions threadsafe. and compile.
  
Author:       discomfitor
Date:         2010-07-21 01:33:25 -0700 (Wed, 21 Jul 2010)
New Revision: 50411

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 08:09:41 UTC (rev 50410)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-21 08:33:25 UTC (rev 50411)
@@ -664,8 +664,12 @@
 EAPI int
 ecore_thread_active_get(void)
 {
+   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   return _ecore_thread_count;
+   pthread_mutex_lock(&_mutex);
+   ret = _ecore_thread_count;
+   pthread_mutex_unlock(&_mutex);
+   return ret;
 #else
    return 0;
 #endif
@@ -680,8 +684,12 @@
 EAPI int
 ecore_thread_pending_get(void)
 {
+   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_pending_job_threads);
+   pthread_mutex_lock(&_mutex);
+   ret = eina_list_count(_ecore_pending_job_threads);
+   pthread_mutex_unlock(&_mutex);
+   return ret;
 #else
    return 0;
 #endif
@@ -696,8 +704,12 @@
 EAPI int
 ecore_thread_pending_long_get(void)
 {
+   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_pending_job_threads_long);
+   pthread_mutex_lock(&_mutex);
+   ret = eina_list_count(_ecore_pending_job_threads_long);
+   pthread_mutex_unlock(&_mutex);
+   return ret;
 #else
    return 0;
 #endif
@@ -712,8 +724,12 @@
 EAPI int
 ecore_thread_pending_total_get(void)
 {
+   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   return eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_long);
+   pthread_mutex_lock(&_mutex);
+   ret = eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_long);
+   pthread_mutex_unlock(&_mutex);
+   return ret;
 #else
    return 0;
 #endif
@@ -728,6 +744,11 @@
 EAPI int
 ecore_thread_max_get(void)
 {
+   int ret;
+   pthread_mutex_lock(&_mutex);
+   ret = _ecore_thread_count_max;
+   pthread_mutex_unlock(&_mutex);
+
    return _ecore_thread_count_max;
 }
 
@@ -744,7 +765,9 @@
    /* avoid doing something hilarious by blocking dumb users */
    if (num >= (2 * eina_cpu_count())) return;
 
+   pthread_mutex_lock(&_mutex);
    _ecore_thread_count_max = num;
+   pthread_mutex_unlock(&_mutex);
 }
 
 /**
@@ -755,7 +778,9 @@
 EAPI void
 ecore_thread_max_reset(void)
 {
+   pthread_mutex_lock(&_mutex);
    _ecore_thread_count_max = eina_cpu_count();
+   pthread_mutex_unlock(&_mutex);
 }
 
 /**
@@ -768,8 +793,12 @@
 EAPI int
 ecore_thread_available_get(void)
 {
+   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   return _ecore_thread_count_max - _ecore_thread_count);
+   pthread_mutex_lock(&_mutex);
+   ret = _ecore_thread_count_max - _ecore_thread_count;
+   pthread_mutex_unlock(&_mutex);
+   return ret;
 #else
    return 0;
 #endif

Log:
  +ecore_thread_pool_data_{add,find,del}: start of ecore_thread_pool api. these calls are used from heavy_run to manage data within a thread pool. more to come
  
Author:       discomfitor
Date:         2010-07-22 13:28:34 -0700 (Thu, 22 Jul 2010)
New Revision: 50438

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-22 18:42:44 UTC (rev 50437)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-22 20:28:34 UTC (rev 50438)
@@ -340,13 +340,17 @@
 				       void (*func_cancel)(void *data),
 				       const void *data);
    EAPI Ecore_Thread *ecore_long_run(void (*func_heavy)(Ecore_Thread *thread,
-							void *data),
-				     void (*func_notify)(Ecore_Thread *thread,
-							 void *msg_data, void *data),
-				     void (*func_end)(void *data),
-				     void (*func_cancel)(void *data),
-				     const void *data,
-				     Eina_Bool try_no_queue);
+							    void *data),
+				       void (*func_notify)(Ecore_Thread *thread,
+							    void *msg_data, void *data),
+           void (*func_end)(void *data),
+           void (*func_cancel)(void *data),
+           const void *data,
+           Eina_Bool try_no_queue);
+   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
+           const void *value);
+   EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
+   EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_check(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_notify(Ecore_Thread *thread, const void *msg_data);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-22 18:42:44 UTC (rev 50437)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-22 20:28:34 UTC (rev 50438)
@@ -18,29 +18,32 @@
 
 struct _Ecore_Pthread_Worker
 {
-   union {
-      struct {
-  void (*func_blocking)(void *data);
-      } short_run;
-      struct {
-  void (*func_heavy)(Ecore_Thread *thread, void *data);
-  void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
+   union
+     {
+       struct
+         {
+            void (*func_blocking)(void *data);
+         } short_run;
+        struct
+          {
+             void (*func_heavy)(Ecore_Thread *thread, void *data);
+             void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
 
-  Ecore_Pipe *notify;
+             Ecore_Pipe *notify;
+             Eina_Hash *hash;
+ #ifdef EFL_HAVE_PTHREAD
+             pthread_t self;
+ #endif
+          } long_run;
+     } u;
 
-#ifdef EFL_HAVE_PTHREAD
-  pthread_t self;
-#endif
-      } long_run;
-   } u;
+    void (*func_cancel)(void *data);
+    void (*func_end)(void *data);
 
-   void (*func_cancel)(void *data);
-   void (*func_end)(void *data);
+    const void *data;
 
-   const void *data;
-
-   Eina_Bool cancel : 1;
-   Eina_Bool long_run : 1;
+    Eina_Bool cancel : 1;
+    Eina_Bool long_run : 1;
 };
 
 #ifdef EFL_HAVE_PTHREAD
@@ -59,6 +62,7 @@
 
 #ifdef EFL_HAVE_PTHREAD
 static int _ecore_thread_count = 0;
+static Eina_Hash *_ecore_thread_global_hash = NULL;
 static Eina_List *_ecore_active_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads_long = NULL;
@@ -114,7 +118,11 @@
           work->func_end((void *) work->data);
      }
 
-   if (work->long_run) ecore_pipe_del(work->u.long_run.notify);
+   if (work->long_run)
+     {
+        ecore_pipe_del(work->u.long_run.notify);
+        eina_hash_free(work->u.long_run.hash);
+     }
    free(work);
 }
 
@@ -538,6 +546,7 @@
 
    worker->u.long_run.func_heavy = func_heavy;
    worker->u.long_run.func_notify = func_notify;
+   worker->u.long_run.hash = NULL;
    worker->func_cancel = func_cancel;
    worker->func_end = func_end;
    worker->data = data;
@@ -606,6 +615,7 @@
     */
    worker.u.long_run.func_heavy = func_heavy;
    worker.u.long_run.func_notify = func_notify;
+   worker->u.long_run.hash = NULL;
    worker.u.long_run.notify = NULL;
    worker.func_cancel = func_cancel;
    worker.func_end = func_end;
@@ -803,3 +813,91 @@
    return 0;
 #endif
 }
+
+/**
+ * @brief Add data to the pool for subsequent uses
+ * @param thread The thread context to add to
+ * @param key The name string to add the data with
+ * @param value The data to add
+ * @return EINA_TRUE on success, EINA_FALSE on failure
+ * This adds data to the thread context, allowing for subsequent users of the thread's pool
+ * to retrieve and use it without complicated mutexing.  This function can only be called by a
+ * heavy_run thread INSIDE the thread and will return EINA_FALSE in any case but success.
+ * All data added to the thread pool must be freed in the thread's func_end/func_cancel
+ * functions to avoid leaks.
+ */
+EAPI Eina_Bool
+ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, const void *value)
+{
+   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   if ((!thread) || (!key) || (!value))
+     return EINA_FALSE;
+#ifdef EFL_HAVE_PTHREAD
+   if (worker->u.long_run.self != pthread_self()) return EINA_FALSE;
+
+   if (!worker->u.long_run.hash)
+     worker->u.long_run.hash = eina_hash_string_small_new(NULL);
+
+   if (!worker->u.long_run.hash)
+     return EINA_FALSE;
+
+   return eina_hash_add(worker->u.long_run.hash, key, value);
+#else
+   return EINA_TRUE;
+#endif
+}
+
+/**
+ * @brief Find data in the pool's data
+ * @param thread The thread context
+ * @param key The name string the data is associated with
+ * @return The value, or NULL on error
+ * This finds data in the thread context that has been previously added with @ref ecore_thread_pool_data_add
+ * This function can only be called by a heavy_run thread INSIDE the thread, and will return NULL
+ * in any case but success.
+ */
+
+EAPI void *
+ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key)
+{
+   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   if ((!thread) || (!key))
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   if (worker->u.long_run.self != pthread_self()) return NULL;
+
+   if (!worker->u.long_run.hash)
+     return NULL;
+
+   return eina_hash_find(worker->u.long_run.hash, key);
+#else
+   return NULL;
+#endif
+}
+
+/**
+ * @brief Delete data from the pool's data
+ * @param thread The thread context
+ * @param key The name string the data is associated with
+ * @return EINA_TRUE on success, EINA_FALSE on failure
+ * This deletes the data pointer from the thread context which was previously added with @ref ecore_thread_pool_data_add
+ * This function can only be called by a heavy_run thread INSIDE the thread, and will return EINA_FALSE
+ * in any case but success.  Note that this WILL NOT free the data, it merely removes it from the thread pool.
+ */
+EAPI Eina_Bool
+ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key)
+{
+   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   if ((!thread) || (!key))
+     return EINA_FALSE;
+#ifdef EFL_HAVE_PTHREAD
+   if (worker->u.long_run.self != pthread_self()) return EINA_FALSE;
+
+   if (!worker->u.long_run.hash)
+     return EINA_FALSE;
+
+   return eina_hash_del_by_key(worker->u.long_run.hash, key);
+#else
+   return EINA_TRUE;
+#endif
+}

Log:
  api change to ecore_thread_pool_data_add, now has 4th argument "direct" to avoid copying key value if desired
  
Author:       discomfitor
Date:         2010-07-22 20:39:52 -0700 (Thu, 22 Jul 2010)
New Revision: 50442

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 03:14:21 UTC (rev 50441)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 03:39:52 UTC (rev 50442)
@@ -348,7 +348,7 @@
            const void *data,
            Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
-           const void *value);
+           const void *value, Eina_Bool direct);
    EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 03:14:21 UTC (rev 50441)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 03:39:52 UTC (rev 50442)
@@ -819,6 +819,7 @@
  * @param thread The thread context to add to
  * @param key The name string to add the data with
  * @param value The data to add
+ * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
  * @return EINA_TRUE on success, EINA_FALSE on failure
  * This adds data to the thread context, allowing for subsequent users of the thread's pool
  * to retrieve and use it without complicated mutexing.  This function can only be called by a
@@ -827,7 +828,7 @@
  * functions to avoid leaks.
  */
 EAPI Eina_Bool
-ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, const void *value)
+ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, const void *value, Eina_Bool direct)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    if ((!thread) || (!key) || (!value))
@@ -840,13 +841,15 @@
 
    if (!worker->u.long_run.hash)
      return EINA_FALSE;
-
+   if (direct)
+     return eina_hash_direct_add(worker->u.long_run.hash, key, value);
    return eina_hash_add(worker->u.long_run.hash, key, value);
 #else
    return EINA_TRUE;
 #endif
 }
 
+
 /**
  * @brief Find data in the pool's data
  * @param thread The thread context

Log:
  +ecore_thread_pool_data_modify_or_add
  
Author:       discomfitor
Date:         2010-07-22 21:17:41 -0700 (Thu, 22 Jul 2010)
New Revision: 50443

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 03:39:52 UTC (rev 50442)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 04:17:41 UTC (rev 50443)
@@ -349,6 +349,8 @@
            Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
            const void *value, Eina_Bool direct);
+   EAPI void         *ecore_thread_pool_data_modify_or_add(Ecore_Thread *thread, const char *key,
+           const void *value);
    EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 03:39:52 UTC (rev 50442)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 04:17:41 UTC (rev 50443)
@@ -849,7 +849,39 @@
 #endif
 }
 
+/**
+ * @brief Modify data in the pool, or add if not found
+ * @param thread The thread context
+ * @param key The name string to add the data with
+ * @param value The data to add
+ * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
+ * @return The old data associated with @p key on success if modified, NULL if added
+ * This adds/modifies data in the thread context, adding only if modify fails.
+ * This function can only be called by a heavy_run thread INSIDE the thread.
+ * All data added to the thread pool must be freed in the thread's func_end/func_cancel
+ * functions to avoid leaks.
+ */
+EAPI void *
+ecore_thread_pool_data_modify_or_add(Ecore_Thread *thread, const char *key, const void *value)
+{
+   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   if ((!thread) || (!key) || (!value))
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   if (worker->u.long_run.self != pthread_self()) return NULL;
 
+   if (!worker->u.long_run.hash)
+     worker->u.long_run.hash = eina_hash_string_small_new(NULL);
+
+   if (!worker->u.long_run.hash)
+     return NULL;
+
+   return eina_hash_modify_or_add(worker->u.long_run.hash, key, value);
+#else
+   return NULL;
+#endif
+}
+
 /**
  * @brief Find data in the pool's data
  * @param thread The thread context

Log:
  remove unnecessary mutexes, expand pthread self member to short_run threads, make thread pool data work on short_run threads, ecore_thread_pool_data_modify_or_add -> ecore_thread_pool_data_set
  
Author:       discomfitor
Date:         2010-07-23 06:08:38 -0700 (Fri, 23 Jul 2010)
New Revision: 50449

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 13:04:21 UTC (rev 50448)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 13:08:38 UTC (rev 50449)
@@ -349,7 +349,7 @@
            Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
            const void *value, Eina_Bool direct);
-   EAPI void         *ecore_thread_pool_data_modify_or_add(Ecore_Thread *thread, const char *key,
+   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key,
            const void *value);
    EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:04:21 UTC (rev 50448)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:08:38 UTC (rev 50449)
@@ -20,25 +20,24 @@
 {
    union
      {
-       struct
-         {
-            void (*func_blocking)(void *data);
-         } short_run;
         struct
           {
+             void (*func_blocking)(void *data);
+           } short_run;
+        struct
+          {
              void (*func_heavy)(Ecore_Thread *thread, void *data);
              void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
-
              Ecore_Pipe *notify;
-             Eina_Hash *hash;
- #ifdef EFL_HAVE_PTHREAD
-             pthread_t self;
- #endif
           } long_run;
      } u;
 
     void (*func_cancel)(void *data);
     void (*func_end)(void *data);
+ #ifdef EFL_HAVE_PTHREAD
+    pthread_t self;
+    Eina_Hash *hash;
+ #endif
 
     const void *data;
 
@@ -119,10 +118,9 @@
      }
 
    if (work->long_run)
-     {
         ecore_pipe_del(work->u.long_run.notify);
-        eina_hash_free(work->u.long_run.hash);
-     }
+
+   eina_hash_free(work->hash);
    free(work);
 }
 
@@ -186,7 +184,7 @@
 
         pthread_mutex_unlock(&_mutex);
 
-        work->u.long_run.self = thread;
+        work->self = thread;
         work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
 
         ecore_pipe_write(end_pipe, &work, sizeof (Ecore_Pthread_Worker *));
@@ -212,7 +210,7 @@
      }
    pth->thread = pthread_self();
 
-   work->u.long_run.self = pth->thread;
+   work->self = pth->thread;
    work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
 
    ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
@@ -546,7 +544,7 @@
 
    worker->u.long_run.func_heavy = func_heavy;
    worker->u.long_run.func_notify = func_notify;
-   worker->u.long_run.hash = NULL;
+   worker->hash = NULL;
    worker->func_cancel = func_cancel;
    worker->func_end = func_end;
    worker->data = data;
@@ -615,7 +613,7 @@
     */
    worker.u.long_run.func_heavy = func_heavy;
    worker.u.long_run.func_notify = func_notify;
-   worker->u.long_run.hash = NULL;
+   worker->hash = NULL;
    worker.u.long_run.notify = NULL;
    worker.func_cancel = func_cancel;
    worker.func_end = func_end;
@@ -653,7 +651,7 @@
    if (!worker->long_run) return EINA_FALSE;
 
 #ifdef EFL_HAVE_PTHREAD
-   if (worker->u.long_run.self != pthread_self()) return EINA_FALSE;
+   if (worker->self != pthread_self()) return EINA_FALSE;
 
    ecore_pipe_write(worker->u.long_run.notify, &data, sizeof (void *));
 
@@ -674,12 +672,8 @@
 EAPI int
 ecore_thread_active_get(void)
 {
-   int ret;
 #ifdef EFL_HAVE_PTHREAD
-   pthread_mutex_lock(&_mutex);
-   ret = _ecore_thread_count;
-   pthread_mutex_unlock(&_mutex);
-   return ret;
+   return _ecore_thread_count;
 #else
    return 0;
 #endif
@@ -754,11 +748,6 @@
 EAPI int
 ecore_thread_max_get(void)
 {
-   int ret;
-   pthread_mutex_lock(&_mutex);
-   ret = _ecore_thread_count_max;
-   pthread_mutex_unlock(&_mutex);
-
    return _ecore_thread_count_max;
 }
 
@@ -775,9 +764,7 @@
    /* avoid doing something hilarious by blocking dumb users */
    if (num >= (2 * eina_cpu_count())) return;
 
-   pthread_mutex_lock(&_mutex);
    _ecore_thread_count_max = num;
-   pthread_mutex_unlock(&_mutex);
 }
 
 /**
@@ -788,9 +775,7 @@
 EAPI void
 ecore_thread_max_reset(void)
 {
-   pthread_mutex_lock(&_mutex);
    _ecore_thread_count_max = eina_cpu_count();
-   pthread_mutex_unlock(&_mutex);
 }
 
 /**
@@ -823,7 +808,7 @@
  * @return EINA_TRUE on success, EINA_FALSE on failure
  * This adds data to the thread context, allowing for subsequent users of the thread's pool
  * to retrieve and use it without complicated mutexing.  This function can only be called by a
- * heavy_run thread INSIDE the thread and will return EINA_FALSE in any case but success.
+ * *_run thread INSIDE the thread and will return EINA_FALSE in any case but success.
  * All data added to the thread pool must be freed in the thread's func_end/func_cancel
  * functions to avoid leaks.
  */
@@ -834,16 +819,16 @@
    if ((!thread) || (!key) || (!value))
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
-   if (worker->u.long_run.self != pthread_self()) return EINA_FALSE;
+   if (worker->self != pthread_self()) return EINA_FALSE;
 
-   if (!worker->u.long_run.hash)
-     worker->u.long_run.hash = eina_hash_string_small_new(NULL);
+   if (!worker->hash)
+     worker->hash = eina_hash_string_small_new(NULL);
 
-   if (!worker->u.long_run.hash)
+   if (!worker->hash)
      return EINA_FALSE;
    if (direct)
-     return eina_hash_direct_add(worker->u.long_run.hash, key, value);
-   return eina_hash_add(worker->u.long_run.hash, key, value);
+     return eina_hash_direct_add(worker->hash, key, value);
+   return eina_hash_add(worker->hash, key, value);
 #else
    return EINA_TRUE;
 #endif
@@ -857,26 +842,26 @@
  * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
  * @return The old data associated with @p key on success if modified, NULL if added
  * This adds/modifies data in the thread context, adding only if modify fails.
- * This function can only be called by a heavy_run thread INSIDE the thread.
+ * This function can only be called by a *_run thread INSIDE the thread.
  * All data added to the thread pool must be freed in the thread's func_end/func_cancel
  * functions to avoid leaks.
  */
 EAPI void *
-ecore_thread_pool_data_modify_or_add(Ecore_Thread *thread, const char *key, const void *value)
+ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, const void *value)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    if ((!thread) || (!key) || (!value))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
-   if (worker->u.long_run.self != pthread_self()) return NULL;
+   if (worker->self != pthread_self()) return NULL;
 
-   if (!worker->u.long_run.hash)
-     worker->u.long_run.hash = eina_hash_string_small_new(NULL);
+   if (!worker->hash)
+     worker->hash = eina_hash_string_small_new(NULL);
 
-   if (!worker->u.long_run.hash)
+   if (!worker->hash)
      return NULL;
 
-   return eina_hash_modify_or_add(worker->u.long_run.hash, key, value);
+   return eina_hash_set(worker->hash, key, value);
 #else
    return NULL;
 #endif
@@ -888,7 +873,7 @@
  * @param key The name string the data is associated with
  * @return The value, or NULL on error
  * This finds data in the thread context that has been previously added with @ref ecore_thread_pool_data_add
- * This function can only be called by a heavy_run thread INSIDE the thread, and will return NULL
+ * This function can only be called by a *_run thread INSIDE the thread, and will return NULL
  * in any case but success.
  */
 
@@ -899,12 +884,12 @@
    if ((!thread) || (!key))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
-   if (worker->u.long_run.self != pthread_self()) return NULL;
+   if (worker->self != pthread_self()) return NULL;
 
-   if (!worker->u.long_run.hash)
+   if (!worker->hash)
      return NULL;
 
-   return eina_hash_find(worker->u.long_run.hash, key);
+   return eina_hash_find(worker->hash, key);
 #else
    return NULL;
 #endif
@@ -916,7 +901,7 @@
  * @param key The name string the data is associated with
  * @return EINA_TRUE on success, EINA_FALSE on failure
  * This deletes the data pointer from the thread context which was previously added with @ref ecore_thread_pool_data_add
- * This function can only be called by a heavy_run thread INSIDE the thread, and will return EINA_FALSE
+ * This function can only be called by a *_run thread INSIDE the thread, and will return EINA_FALSE
  * in any case but success.  Note that this WILL NOT free the data, it merely removes it from the thread pool.
  */
 EAPI Eina_Bool
@@ -926,12 +911,12 @@
    if ((!thread) || (!key))
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
-   if (worker->u.long_run.self != pthread_self()) return EINA_FALSE;
+   if (worker->self != pthread_self()) return EINA_FALSE;
 
-   if (!worker->u.long_run.hash)
+   if (!worker->hash)
      return EINA_FALSE;
 
-   return eina_hash_del_by_key(worker->u.long_run.hash, key);
+   return eina_hash_del_by_key(worker->hash, key);
 #else
    return EINA_TRUE;
 #endif

Log:
  fix doxy
  
Author:       discomfitor
Date:         2010-07-23 06:12:42 -0700 (Fri, 23 Jul 2010)
New Revision: 50450

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:08:38 UTC (rev 50449)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:12:42 UTC (rev 50450)
@@ -333,8 +333,9 @@
 #endif
 }
 /**
- * @defgroup Ecore_Thread Ecore Thread Functions
+ * @addtogroup Ecore_Thread Ecore Thread Functions
  * These functions allow for ecore-managed threads which integrate with ecore's main loop.
+ * @{
  */
 
 /**
@@ -921,3 +922,7 @@
    return EINA_TRUE;
 #endif
 }
+
+/**
+ * @}
+ */

Log:
  add threadsafe global data to threads, allowing for communication between threads and other threads and threads and main loop
  
Author:       discomfitor
Date:         2010-07-23 08:33:22 -0700 (Fri, 23 Jul 2010)
New Revision: 50453

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 15:31:43 UTC (rev 50452)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 15:33:22 UTC (rev 50453)
@@ -347,12 +347,6 @@
            void (*func_cancel)(void *data),
            const void *data,
            Eina_Bool try_no_queue);
-   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
-           const void *value, Eina_Bool direct);
-   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key,
-           const void *value);
-   EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
-   EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_check(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_notify(Ecore_Thread *thread, const void *msg_data);
@@ -365,7 +359,20 @@
    EAPI void          ecore_thread_max_reset(void);
    EAPI int           ecore_thread_available_get(void);
 
+   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
+           const void *value, Eina_Bool direct);
+   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key,
+           const void *value);
+   EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
+   EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
 
+   EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, const void *value,
+           Eina_Bool direct);
+   EAPI void         *ecore_thread_global_data_set(const char *key, const void *value);
+   EAPI void         *ecore_thread_global_data_find(const char *key);
+   EAPI Eina_Bool     ecore_thread_global_data_del(const char *key);
+
+
    EAPI double ecore_time_get(void);
    EAPI double ecore_loop_time_get(void);
 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 15:31:43 UTC (rev 50452)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 15:33:22 UTC (rev 50453)
@@ -61,14 +61,15 @@
 
 #ifdef EFL_HAVE_PTHREAD
 static int _ecore_thread_count = 0;
-static Eina_Hash *_ecore_thread_global_hash = NULL;
+
 static Eina_List *_ecore_active_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads = NULL;
 static Eina_List *_ecore_pending_job_threads_long = NULL;
 static Ecore_Event_Handler *del_handler = NULL;
-
 static pthread_mutex_t _ecore_pending_job_threads_mutex = PTHREAD_MUTEX_INITIALIZER;
 
+static Eina_Hash *_ecore_thread_global_hash = NULL;
+static pthread_rwlock_t _ecore_thread_global_hash_lock = PTHREAD_RWLOCK_INITIALIZER;
 static void
 _ecore_thread_pipe_free(void *data __UNUSED__, void *event)
 {
@@ -924,5 +925,128 @@
 }
 
 /**
+ * @brief Add data to the global data
+ * @param key The name string to add the data with
+ * @param value The data to add
+ * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
+ * @return EINA_TRUE on success, EINA_FALSE on failure
+ * This adds data to the global thread data, and will return EINA_FALSE in any case but success.
+ * All data added to global should be manually freed to avoid stale pointers in the global thread data.
+ */
+EAPI Eina_Bool
+ecore_thread_global_data_add(const char *key, const void *value, Eina_Bool direct)
+{
+   Eina_Bool ret;
+   if ((!key) || (!value))
+     return EINA_FALSE;
+#ifdef EFL_HAVE_PTHREAD
+   pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   if (!_ecore_thread_global_hash)
+     _ecore_thread_global_hash = eina_hash_string_small_new(NULL);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+
+   if (!_ecore_thread_global_hash)
+     return EINA_FALSE;
+   pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   if (direct)
+     ret = eina_hash_direct_add(_ecore_thread_global_hash, key, value);
+   else
+     ret = eina_hash_add(_ecore_thread_global_hash, key, value);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   return ret;
+#else
+   return EINA_TRUE;
+#endif
+}
+
+/**
+ * @brief Add data to the global data
+ * @param key The name string to add the data with
+ * @param value The data to add
+ * @return EINA_TRUE on success, EINA_FALSE on failure
+ * This adds data to the global thread data and returns NULL, or replaces the previous data
+ * associated with @p key and returning the previous data if it existed.  To see if an error occurred,
+ * one must use eina_error_get.
+ * All data added to global should be manually freed to avoid stale pointers in the global thread data.
+ */
+EAPI void *
+ecore_thread_global_data_set(const char *key, const void *value)
+{
+   void *ret;
+   if ((!key) || (!value))
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   if (!_ecore_thread_global_hash)
+     _ecore_thread_global_hash = eina_hash_string_small_new(NULL);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+
+   if (!_ecore_thread_global_hash)
+     return NULL;
+
+   pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   ret = eina_hash_set(_ecore_thread_global_hash, key, value);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   return ret;
+#else
+   return NULL;
+#endif
+}
+
+/**
+ * @brief Find data in the global data
+ * @param key The name string the data is associated with
+ * @return The value, or NULL on error
+ * This finds data in the global data that has been previously added with @ref ecore_thread_global_data_add
+ * This function will return NULL in any case but success.
+ */
+
+EAPI void *
+ecore_thread_global_data_find(const char *key)
+{
+   void *ret;
+   if (!key)
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   if (!_ecore_thread_global_hash) return NULL;
+
+   pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
+   ret = eina_hash_find(_ecore_thread_global_hash, key);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   return ret;
+#else
+   return NULL;
+#endif
+}
+
+/**
+ * @brief Delete data from the global data
+ * @param key The name string the data is associated with
+ * @return EINA_TRUE on success, EINA_FALSE on failure
+ * This deletes the data pointer from the global data which was previously added with @ref ecore_thread_global_data_add
+ * This function will return EINA_FALSE in any case but success.
+ * Note that this WILL NOT free the data, it merely removes it from the global set.
+ */
+EAPI Eina_Bool
+ecore_thread_global_data_del(const char *key)
+{
+   Eina_Bool ret;
+   if (!key)
+     return EINA_FALSE;
+#ifdef EFL_HAVE_PTHREAD
+   if (!_ecore_thread_global_hash)
+     return EINA_FALSE;
+
+   pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   ret = eina_hash_del_by_key(_ecore_thread_global_hash, key);
+   pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   return ret;
+#else
+   return EINA_TRUE;
+#endif
+}
+
+
+/**
  * @}
  */

Log:
  rename mutex
  
Author:       discomfitor
Date:         2010-07-23 06:35:14 -0700 (Fri, 23 Jul 2010)
New Revision: 50451

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:12:42 UTC (rev 50450)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 13:35:14 UTC (rev 50451)
@@ -67,7 +67,7 @@
 static Eina_List *_ecore_pending_job_threads_long = NULL;
 static Ecore_Event_Handler *del_handler = NULL;
 
-static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t _ecore_pending_job_threads_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 static void
 _ecore_thread_pipe_free(void *data __UNUSED__, void *event)
@@ -145,18 +145,18 @@
 
    while (_ecore_pending_job_threads)
      {
-        pthread_mutex_lock(&_mutex);
+        pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
 
         if (!_ecore_pending_job_threads)
           {
-             pthread_mutex_unlock(&_mutex);
+             pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
              break;
           }
 
         work = eina_list_data_get(_ecore_pending_job_threads);
         _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, _ecore_pending_job_threads);
 
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
         work->u.short_run.func_blocking((void *) work->data);
 
@@ -171,18 +171,18 @@
 
    while (_ecore_pending_job_threads_long)
      {
-        pthread_mutex_lock(&_mutex);
+        pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
 
         if (!_ecore_pending_job_threads_long)
           {
-             pthread_mutex_unlock(&_mutex);
+             pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
              break;
           }
 
         work = eina_list_data_get(_ecore_pending_job_threads_long);
         _ecore_pending_job_threads_long = eina_list_remove_list(_ecore_pending_job_threads_long, _ecore_pending_job_threads_long);
 
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
         work->self = thread;
         work->u.long_run.func_heavy((Ecore_Thread *) work, (void *) work->data);
@@ -243,9 +243,9 @@
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    _ecore_thread_count++;
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
  on_error:
    if (_ecore_pending_job_threads) _ecore_short_job(pth->p);
@@ -253,21 +253,21 @@
 
    /* FIXME: Check if there is long running task todo, and switch to long run handler. */
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    if (_ecore_pending_job_threads)
      {
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
         goto on_error;
      }
    if (_ecore_pending_job_threads_long)
      {
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
         goto on_error;
      }
 
    _ecore_thread_count--;
 
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
    work = malloc(sizeof (Ecore_Pthread_Worker));
    if (!work) return NULL;
@@ -307,7 +307,7 @@
    Ecore_Pthread_Worker *work;
    Ecore_Pthread_Data *pth;
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
 
    EINA_LIST_FREE(_ecore_pending_job_threads, work)
      {
@@ -316,7 +316,7 @@
         free(work);
      }
 
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
    EINA_LIST_FREE(_ecore_active_job_threads, pth)
      {
@@ -384,16 +384,16 @@
    work->long_run = EINA_FALSE;
    work->data = data;
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    _ecore_pending_job_threads = eina_list_append(_ecore_pending_job_threads, work);
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
         return (Ecore_Thread *) work;
      }
 
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
    /* One more thread could be created. */
    pth = malloc(sizeof (Ecore_Pthread_Data));
@@ -454,14 +454,14 @@
    Ecore_Pthread_Worker *work;
    Eina_List *l;
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
 
    EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)
      if ((void *) work == (void *) thread)
        {
          _ecore_pending_job_threads = eina_list_remove_list(_ecore_pending_job_threads, l);
 
-         pthread_mutex_unlock(&_mutex);
+         pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
          if (work->func_cancel)
            work->func_cancel((void *) work->data);
@@ -470,7 +470,7 @@
          return EINA_TRUE;
        }
 
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
    /* Delay the destruction */
    ((Ecore_Pthread_Worker *)thread)->cancel = EINA_TRUE;
@@ -562,16 +562,16 @@
           return (Ecore_Thread *) worker;
      }
 
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    _ecore_pending_job_threads_long = eina_list_append(_ecore_pending_job_threads_long, worker);
 
    if (_ecore_thread_count == _ecore_thread_count_max)
      {
-        pthread_mutex_unlock(&_mutex);
+        pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
         return (Ecore_Thread *) worker;
      }
 
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
 
    /* One more thread could be created. */
    pth = malloc(sizeof (Ecore_Pthread_Data));
@@ -691,9 +691,9 @@
 {
    int ret;
 #ifdef EFL_HAVE_PTHREAD
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads);
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
    return ret;
 #else
    return 0;
@@ -711,9 +711,9 @@
 {
    int ret;
 #ifdef EFL_HAVE_PTHREAD
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads_long);
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
    return ret;
 #else
    return 0;
@@ -731,9 +731,9 @@
 {
    int ret;
 #ifdef EFL_HAVE_PTHREAD
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    ret = eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_long);
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
    return ret;
 #else
    return 0;
@@ -791,9 +791,9 @@
 {
    int ret;
 #ifdef EFL_HAVE_PTHREAD
-   pthread_mutex_lock(&_mutex);
+   pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
    ret = _ecore_thread_count_max - _ecore_thread_count;
-   pthread_mutex_unlock(&_mutex);
+   pthread_mutex_unlock(&_ecore_pending_job_threads_mutex);
    return ret;
 #else
    return 0;

Log:
  +ecore_thread_{global,pool}_data_wait, to allow waiting for data in the global or pool data contexts and simulate g_async_queue in a less mutexy fashion
  
Author:       discomfitor
Date:         2010-07-23 09:24:35 -0700 (Fri, 23 Jul 2010)
New Revision: 50454

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 15:33:22 UTC (rev 50453)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 16:24:35 UTC (rev 50454)
@@ -371,6 +371,7 @@
    EAPI void         *ecore_thread_global_data_set(const char *key, const void *value);
    EAPI void         *ecore_thread_global_data_find(const char *key);
    EAPI Eina_Bool     ecore_thread_global_data_del(const char *key);
+   EAPI void         *ecore_thread_global_data_wait(const char *key, double seconds);
 
 
    EAPI double ecore_time_get(void);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 15:33:22 UTC (rev 50453)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 16:24:35 UTC (rev 50454)
@@ -925,6 +925,47 @@
 }
 
 /**
+ * @brief Find data in the pool data and optionally wait for the data if not found
+ * @param key The name string the data is associated with
+ * @param seconds The amount of time in seconds to wait for the data.  If 0, the call will be async and not wait for data.
+ * If < 0 the call will wait indefinitely for the data.
+ * @return The value, or NULL on failure
+ * This finds data in the pool data that has been previously added with @ref ecore_thread_pool_data_add
+ * This function will return NULL in any case but success.
+ * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
+ */
+EAPI void *
+ecore_thread_pool_data_wait(const char *key, double seconds)
+{
+   double time = 0;
+   void *ret;
+   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   if ((!thread) || (!key))
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   if (worker->self != pthread_self()) return NULL;
+   if (seconds > 0)
+     time = ecore_time_get() + seconds;
+
+   while (1)
+     {
+        ret = eina_hash_find(thread->hash, key);
+        if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
+          break;
+        //try to sleep for a reasonable amount of time
+        if (time)
+          usleep((seconds * 1000000) / 2);
+        else
+          usleep(1000000);
+     }
+   return ret;
+#else
+   return NULL;
+#endif
+}
+
+
+/**
  * @brief Add data to the global data
  * @param key The name string to add the data with
  * @param value The data to add
@@ -1046,7 +1087,48 @@
 #endif
 }
 
+/**
+ * @brief Find data in the global data and optionally wait for the data if not found
+ * @param key The name string the data is associated with
+ * @param seconds The amount of time in seconds to wait for the data.  If 0, the call will be async and not wait for data.
+ * If < 0 the call will wait indefinitely for the data.
+ * @return The value, or NULL on failure
+ * This finds data in the global data that has been previously added with @ref ecore_thread_global_data_add
+ * This function will return NULL in any case but success.
+ * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
+ */
+EAPI void *
+ecore_thread_global_data_wait(const char *key, double seconds)
+{
+   double time = 0;
+   void *ret = NULL;
+   if (!key)
+     return NULL;
+#ifdef EFL_HAVE_PTHREAD
+   if (!_ecore_thread_global_hash)
+     return NULL;
+   if (seconds > 0)
+     time = ecore_time_get() + seconds;
 
+   while (1)
+     {
+        pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
+        ret = eina_hash_find(_ecore_thread_global_hash, key);
+        pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+        if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
+          break;
+        //try to sleep for a reasonable amount of time
+        if (time)
+          usleep((seconds * 1000000) / 2);
+        else
+          usleep(1000000);
+     }
+   return ret;
+#else
+   return NULL;
+#endif
+}
+
 /**
  * @}
  */

Log:
  whoops
  
Author:       discomfitor
Date:         2010-07-23 09:40:40 -0700 (Fri, 23 Jul 2010)
New Revision: 50455

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 16:24:35 UTC (rev 50454)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-23 16:40:40 UTC (rev 50455)
@@ -365,6 +365,7 @@
            const void *value);
    EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
+   EAPI void         *ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds);
 
    EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, const void *value,
            Eina_Bool direct);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 16:24:35 UTC (rev 50454)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 16:40:40 UTC (rev 50455)
@@ -935,7 +935,7 @@
  * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
  */
 EAPI void *
-ecore_thread_pool_data_wait(const char *key, double seconds)
+ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds)
 {
    double time = 0;
    void *ret;
@@ -949,7 +949,7 @@
 
    while (1)
      {
-        ret = eina_hash_find(thread->hash, key);
+        ret = eina_hash_find(worker->hash, key);
         if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
           break;
         //try to sleep for a reasonable amount of time

Log:
  fix leak in thread_shutdown, use lots of mutexes and conditionals instead of sleeps to wait in data_wait functions
  
Author:       discomfitor
Date:         2010-07-23 10:30:21 -0700 (Fri, 23 Jul 2010)
New Revision: 50459

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 17:22:52 UTC (rev 50458)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 17:30:21 UTC (rev 50459)
@@ -37,6 +37,8 @@
  #ifdef EFL_HAVE_PTHREAD
     pthread_t self;
     Eina_Hash *hash;
+    pthread_cond_t cond;
+    pthread_mutex_t mutex;
  #endif
 
     const void *data;
@@ -70,6 +72,8 @@
 
 static Eina_Hash *_ecore_thread_global_hash = NULL;
 static pthread_rwlock_t _ecore_thread_global_hash_lock = PTHREAD_RWLOCK_INITIALIZER;
+static pthread_mutex_t _ecore_thread_global_hash_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t _ecore_thread_global_hash_cond = PTHREAD_COND_INITIALIZER;
 static void
 _ecore_thread_pipe_free(void *data __UNUSED__, void *event)
 {
@@ -120,7 +124,8 @@
 
    if (work->long_run)
         ecore_pipe_del(work->u.long_run.notify);
-
+   pthread_cond_destroy(&work->cond);
+   pthread_mutex_destroy(&work->mutex);
    eina_hash_free(work->hash);
    free(work);
 }
@@ -328,7 +333,7 @@
 
         ecore_pipe_del(pth->p);
      }
-
+   eina_hash_free(_ecore_thread_global_hash);
    ecore_event_handler_del(del_handler);
    del_handler = NULL;
 #endif
@@ -379,6 +384,9 @@
      }
 
    work->u.short_run.func_blocking = func_blocking;
+   work->hash = NULL;
+   pthread_cond_init(&work->cond, NULL);
+   pthread_mutex_init(&work->mutex, NULL);
    work->func_end = func_end;
    work->func_cancel = func_cancel;
    work->cancel = EINA_FALSE;
@@ -547,6 +555,8 @@
    worker->u.long_run.func_heavy = func_heavy;
    worker->u.long_run.func_notify = func_notify;
    worker->hash = NULL;
+   pthread_cond_init(&worker->cond, NULL);
+   pthread_mutex_init(&worker->mutex, NULL);
    worker->func_cancel = func_cancel;
    worker->func_end = func_end;
    worker->data = data;
@@ -616,6 +626,8 @@
    worker.u.long_run.func_heavy = func_heavy;
    worker.u.long_run.func_notify = func_notify;
    worker->hash = NULL;
+   pthread_cond_init(&worker->cond, NULL);
+   pthread_mutex_init(&worker->mutex, NULL);
    worker.u.long_run.notify = NULL;
    worker.func_cancel = func_cancel;
    worker.func_end = func_end;
@@ -818,6 +830,8 @@
 ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, const void *value, Eina_Bool direct)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   Eina_Bool ret;
+
    if ((!thread) || (!key) || (!value))
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
@@ -829,6 +843,13 @@
    if (!worker->hash)
      return EINA_FALSE;
    if (direct)
+     ret = eina_hash_direct_add(worker->hash, key, value);
+   else
+     ret = eina_hash_add(worker->hash, key, value);
+   pthread_cond_broadcast(&worker->cond);
+   return ret;
+
+   if (direct)
      return eina_hash_direct_add(worker->hash, key, value);
    return eina_hash_add(worker->hash, key, value);
 #else
@@ -852,6 +873,7 @@
 ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, const void *value)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   void *ret;
    if ((!thread) || (!key) || (!value))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
@@ -863,7 +885,9 @@
    if (!worker->hash)
      return NULL;
 
-   return eina_hash_set(worker->hash, key, value);
+   ret = eina_hash_set(worker->hash, key, value);
+   pthread_cond_broadcast(&worker->cond);
+   return ret;
 #else
    return NULL;
 #endif
@@ -952,11 +976,9 @@
         ret = eina_hash_find(worker->hash, key);
         if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
           break;
-        //try to sleep for a reasonable amount of time
-        if (time)
-          usleep((seconds * 1000000) / 2);
-        else
-          usleep(1000000);
+        pthread_mutex_lock(&worker->mutex);
+        pthread_cond_wait(&worker->cond, &worker->mutex);
+        pthread_mutex_unlock(&worker->mutex);
      }
    return ret;
 #else
@@ -994,6 +1016,7 @@
    else
      ret = eina_hash_add(_ecore_thread_global_hash, key, value);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
    return ret;
 #else
    return EINA_TRUE;
@@ -1028,6 +1051,7 @@
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
    ret = eina_hash_set(_ecore_thread_global_hash, key, value);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
+   pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
    return ret;
 #else
    return NULL;
@@ -1117,11 +1141,9 @@
         pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
         if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
           break;
-        //try to sleep for a reasonable amount of time
-        if (time)
-          usleep((seconds * 1000000) / 2);
-        else
-          usleep(1000000);
+        pthread_mutex_lock(&_ecore_thread_global_hash_mutex);
+        pthread_cond_wait(&_ecore_thread_global_hash_cond, &_ecore_thread_global_hash_mutex);
+        pthread_mutex_unlock(&_ecore_thread_global_hash_mutex);
      }
    return ret;
 #else

Log:
  shut up eina
  
Author:       discomfitor
Date:         2010-07-23 10:52:50 -0700 (Fri, 23 Jul 2010)
New Revision: 50460

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 17:30:21 UTC (rev 50459)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 17:52:50 UTC (rev 50460)
@@ -126,7 +126,8 @@
         ecore_pipe_del(work->u.long_run.notify);
    pthread_cond_destroy(&work->cond);
    pthread_mutex_destroy(&work->mutex);
-   eina_hash_free(work->hash);
+   if (work->hash)
+     eina_hash_free(work->hash);
    free(work);
 }
 
@@ -333,7 +334,8 @@
 
         ecore_pipe_del(pth->p);
      }
-   eina_hash_free(_ecore_thread_global_hash);
+   if (_ecore_thread_global_hash)
+     eina_hash_free(_ecore_thread_global_hash);
    ecore_event_handler_del(del_handler);
    del_handler = NULL;
 #endif

Log:
  correctly init some variables that I missed somehow.  I blame Sachiel.
  
Author:       discomfitor
Date:         2010-07-23 15:28:18 -0700 (Fri, 23 Jul 2010)
New Revision: 50465

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 21:56:25 UTC (rev 50464)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-23 22:28:18 UTC (rev 50465)
@@ -236,6 +236,9 @@
    work->func_cancel = NULL;
    work->cancel = EINA_FALSE;
    work->long_run = EINA_FALSE;
+   work->hash = NULL;
+   pthread_cond_init(&work->cond, NULL);
+   pthread_mutex_init(&work->mutex, NULL);
 
    ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));
 
@@ -285,6 +288,9 @@
    work->func_cancel = NULL;
    work->cancel = EINA_FALSE;
    work->long_run = EINA_FALSE;
+   work->hash = NULL;
+   pthread_cond_init(&work->cond, NULL);
+   pthread_mutex_init(&work->mutex, NULL);
 
    ecore_pipe_write(pth->p, &work, sizeof (Ecore_Pthread_Worker *));

Log:
  fix longstanding leak
  
Author:       discomfitor
Date:         2010-07-23 19:05:35 -0700 (Fri, 23 Jul 2010)
New Revision: 50470

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-24 02:04:53 UTC (rev 50469)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-24 02:05:35 UTC (rev 50470)
@@ -100,6 +100,7 @@
    _ecore_active_job_threads = eina_list_remove(_ecore_active_job_threads, pth);
 
    ecore_event_add(ECORE_THREAD_PIPE_DEL, pth->p, _ecore_thread_pipe_free, NULL);
+   free(pth);
 }
 
 static void

Log:
  add typedefs for ecore thread function types because I'm tired of typing them out
  
Author:       discomfitor
Date:         2010-07-25 21:20:18 -0700 (Sun, 25 Jul 2010)
New Revision: 50499

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-26 03:17:40 UTC (rev 50498)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-26 04:20:18 UTC (rev 50499)
@@ -167,7 +167,14 @@
    typedef struct _Ecore_Exe_Event_Data_Line   Ecore_Exe_Event_Data_Line; /**< Lines from a child process */
    typedef struct _Ecore_Exe_Event_Data        Ecore_Exe_Event_Data; /**< Data from a child process */
    typedef struct _Ecore_Thread                Ecore_Thread;
+   typedef void (*Ecore_Thread_Func_Blocking) (void *data);
+   typedef void (*Ecore_Thread_Func_End) (void *data);
+   typedef void (*Ecore_Thread_Func_Cancel) (void *data);
+   typedef void (*Ecore_Thread_Func_Heavy) (Ecore_Thread *thread, void *data);
+   typedef void (*Ecore_Thread_Func_Notify) (Ecore_Thread *thread, void *msg_data, void *data);
 
+
+
    typedef struct _Ecore_Job Ecore_Job; /**< A job handle */
 
    struct _Ecore_Event_Signal_User /** User signal event */
@@ -335,18 +342,16 @@
    EAPI void         ecore_pipe_write_close(Ecore_Pipe *p);
    EAPI void         ecore_pipe_read_close(Ecore_Pipe *p);
 
-   EAPI Ecore_Thread *ecore_thread_run(void (*func_blocking)(void *data),
-				       void (*func_end)(void *data),
-				       void (*func_cancel)(void *data),
+   EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Func_Blocking,
+				       Ecore_Thread_Func_End,
+				       Ecore_Thread_Func_Cancel,
 				       const void *data);
-   EAPI Ecore_Thread *ecore_long_run(void (*func_heavy)(Ecore_Thread *thread,
-							    void *data),
-				       void (*func_notify)(Ecore_Thread *thread,
-							    void *msg_data, void *data),
-           void (*func_end)(void *data),
-           void (*func_cancel)(void *data),
-           const void *data,
-           Eina_Bool try_no_queue);
+   EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy,
+				     Ecore_Thread_Func_Notify,
+                                     Ecore_Thread_Func_End,
+                                     Ecore_Thread_Func_Cancel,
+                                     const void *data,
+                                     Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_check(Ecore_Thread *thread);
    EAPI Eina_Bool     ecore_thread_notify(Ecore_Thread *thread, const void *msg_data);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 03:17:40 UTC (rev 50498)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 04:20:18 UTC (rev 50499)
@@ -374,10 +374,10 @@
  * host CPU can handle.
  */
 EAPI Ecore_Thread *
-ecore_thread_run(void (*func_blocking)(void *data),
-   void (*func_end)(void *data),
-   void (*func_cancel)(void *data),
-   const void *data)
+ecore_thread_run(Ecore_Thread_Func_Blocking,
+                 Ecore_Thread_Func_End,
+                 Ecore_Thread_Func_Cancel,
+                 const void *data)
 {
 #ifdef EFL_HAVE_PTHREAD
    Ecore_Pthread_Worker *work;
@@ -543,13 +543,12 @@
  * the CPU down, so be carefull with that. Of course if it can't start a new thread, it will
  * try to use one from the pool.
  */
-EAPI Ecore_Thread *
-ecore_long_run(void (*func_heavy)(Ecore_Thread *thread, void *data),
-        void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data),
-        void (*func_end)(void *data),
-        void (*func_cancel)(void *data),
-        const void *data,
-        Eina_Bool try_no_queue)
+EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy,
+                                  Ecore_Thread_Func_Notify,
+                                  Ecore_Thread_Func_End,
+                                  Ecore_Thread_Func_Cancel,
+                                  const void *data,
+                                  Eina_Bool try_no_queue)
 {
 
 #ifdef EFL_HAVE_PTHREAD

Log:
  whoops
  
Author:       discomfitor
Date:         2010-07-25 22:47:33 -0700 (Sun, 25 Jul 2010)
New Revision: 50504

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 05:37:36 UTC (rev 50503)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 05:47:33 UTC (rev 50504)
@@ -374,9 +374,9 @@
  * host CPU can handle.
  */
 EAPI Ecore_Thread *
-ecore_thread_run(Ecore_Thread_Func_Blocking,
-                 Ecore_Thread_Func_End,
-                 Ecore_Thread_Func_Cancel,
+ecore_thread_run(Ecore_Thread_Func_Blocking func_blocking,
+                 Ecore_Thread_Func_End func_end,
+                 Ecore_Thread_Func_Cancel func_cancel,
                  const void *data)
 {
 #ifdef EFL_HAVE_PTHREAD
@@ -543,10 +543,10 @@
  * the CPU down, so be carefull with that. Of course if it can't start a new thread, it will
  * try to use one from the pool.
  */
-EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy,
-                                  Ecore_Thread_Func_Notify,
-                                  Ecore_Thread_Func_End,
-                                  Ecore_Thread_Func_Cancel,
+EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy func_heavy,
+                                  Ecore_Thread_Func_Notify func_notify,
+                                  Ecore_Thread_Func_End func_end,
+                                  Ecore_Thread_Func_Cancel func_cancel,
                                   const void *data,
                                   Eina_Bool try_no_queue)
 {

Log:
  rename function typedefs
  
Author:       discomfitor
Date:         2010-07-26 00:19:27 -0700 (Mon, 26 Jul 2010)
New Revision: 50506

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-26 06:52:36 UTC (rev 50505)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-26 07:19:27 UTC (rev 50506)
@@ -167,11 +167,11 @@
    typedef struct _Ecore_Exe_Event_Data_Line   Ecore_Exe_Event_Data_Line; /**< Lines from a child process */
    typedef struct _Ecore_Exe_Event_Data        Ecore_Exe_Event_Data; /**< Data from a child process */
    typedef struct _Ecore_Thread                Ecore_Thread;
-   typedef void (*Ecore_Thread_Func_Blocking) (void *data);
-   typedef void (*Ecore_Thread_Func_End) (void *data);
-   typedef void (*Ecore_Thread_Func_Cancel) (void *data);
-   typedef void (*Ecore_Thread_Func_Heavy) (Ecore_Thread *thread, void *data);
-   typedef void (*Ecore_Thread_Func_Notify) (Ecore_Thread *thread, void *msg_data, void *data);
+   typedef void (*Ecore_Thread_Blocking_Cb) (void *data);
+   typedef void (*Ecore_Thread_End_Cb) (void *data);
+   typedef void (*Ecore_Thread_Cancel_Cb) (void *data);
+   typedef void (*Ecore_Thread_Heavy_Cb) (Ecore_Thread *thread, void *data);
+   typedef void (*Ecore_Thread_Notify_Cb) (Ecore_Thread *thread, void *msg_data, void *data);
 
 
 
@@ -342,14 +342,14 @@
    EAPI void         ecore_pipe_write_close(Ecore_Pipe *p);
    EAPI void         ecore_pipe_read_close(Ecore_Pipe *p);
 
-   EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Func_Blocking,
-				       Ecore_Thread_Func_End,
-				       Ecore_Thread_Func_Cancel,
+   EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Blocking_Cb,
+				       Ecore_Thread_End_Cb,
+				       Ecore_Thread_Cancel_Cb,
 				       const void *data);
-   EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy,
-				     Ecore_Thread_Func_Notify,
-                                     Ecore_Thread_Func_End,
-                                     Ecore_Thread_Func_Cancel,
+   EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Heavy_Cb,
+				     Ecore_Thread_Notify_Cb,
+                                     Ecore_Thread_End_Cb,
+                                     Ecore_Thread_Cancel_Cb,
                                      const void *data,
                                      Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 06:52:36 UTC (rev 50505)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 07:19:27 UTC (rev 50506)
@@ -374,9 +374,9 @@
  * host CPU can handle.
  */
 EAPI Ecore_Thread *
-ecore_thread_run(Ecore_Thread_Func_Blocking func_blocking,
-                 Ecore_Thread_Func_End func_end,
-                 Ecore_Thread_Func_Cancel func_cancel,
+ecore_thread_run(Ecore_Thread_Blocking_Cb func_blocking,
+                 Ecore_Thread_End_Cb func_end,
+                 Ecore_Thread_Cancel_Cb func_cancel,
                  const void *data)
 {
 #ifdef EFL_HAVE_PTHREAD
@@ -543,10 +543,10 @@
  * the CPU down, so be carefull with that. Of course if it can't start a new thread, it will
  * try to use one from the pool.
  */
-EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Func_Heavy func_heavy,
-                                  Ecore_Thread_Func_Notify func_notify,
-                                  Ecore_Thread_Func_End func_end,
-                                  Ecore_Thread_Func_Cancel func_cancel,
+EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Heavy_Cb func_heavy,
+                                  Ecore_Thread_Notify_Cb func_notify,
+                                  Ecore_Thread_End_Cb func_end,
+                                  Ecore_Thread_Cancel_Cb func_cancel,
                                   const void *data,
                                   Eina_Bool try_no_queue)
 {

Log:
  ecore_thread_cancel is now nullsafe, returning EINA_TRUE
  
Author:       discomfitor
Date:         2010-07-26 13:41:54 -0700 (Mon, 26 Jul 2010)
New Revision: 50523

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 20:37:41 UTC (rev 50522)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-26 20:41:54 UTC (rev 50523)
@@ -472,6 +472,9 @@
    Ecore_Pthread_Worker *work;
    Eina_List *l;
 
+   if (!work)
+     return EINA_TRUE;
+
    pthread_mutex_lock(&_ecore_pending_job_threads_mutex);
 
    EINA_LIST_FOREACH(_ecore_pending_job_threads, l, work)

Log:
  fix threadless compile
  
Author:       discomfitor
Date:         2010-07-26 20:59:04 -0700 (Mon, 26 Jul 2010)
New Revision: 50528

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-27 01:05:13 UTC (rev 50527)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-27 03:59:04 UTC (rev 50528)
@@ -636,9 +636,6 @@
     */
    worker.u.long_run.func_heavy = func_heavy;
    worker.u.long_run.func_notify = func_notify;
-   worker->hash = NULL;
-   pthread_cond_init(&worker->cond, NULL);
-   pthread_mutex_init(&worker->mutex, NULL);
    worker.u.long_run.notify = NULL;
    worker.func_cancel = func_cancel;
    worker.func_end = func_end;

Log:
  add data freeing support to ecore thread data api
  TO FUTURE MIKE: you were too tired to update the doxy last night and instead of writing the doxy updates you fell asleeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
  
Author:       discomfitor
Date:         2010-07-30 01:52:18 -0700 (Fri, 30 Jul 2010)
New Revision: 50682

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-30 08:29:13 UTC (rev 50681)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-30 08:52:18 UTC (rev 50682)
@@ -166,6 +166,13 @@
    typedef struct _Ecore_Exe_Event_Del         Ecore_Exe_Event_Del; /**< Spawned Exe exit event */
    typedef struct _Ecore_Exe_Event_Data_Line   Ecore_Exe_Event_Data_Line; /**< Lines from a child process */
    typedef struct _Ecore_Exe_Event_Data        Ecore_Exe_Event_Data; /**< Data from a child process */
+
+
+   typedef struct _Ecore_Thread_Data
+   {
+      void *data;
+      Eina_Free_Cb cb;
+   } Ecore_Thread_Data;
    typedef struct _Ecore_Thread                Ecore_Thread;
    typedef void (*Ecore_Thread_Blocking_Cb) (void *data);
    typedef void (*Ecore_Thread_End_Cb) (void *data);
@@ -342,12 +349,14 @@
    EAPI void         ecore_pipe_write_close(Ecore_Pipe *p);
    EAPI void         ecore_pipe_read_close(Ecore_Pipe *p);
 
+
+
    EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Blocking_Cb,
-				       Ecore_Thread_End_Cb,
-				       Ecore_Thread_Cancel_Cb,
-				       const void *data);
+                                       Ecore_Thread_End_Cb,
+                                       Ecore_Thread_Cancel_Cb,
+                                       const void *data);
    EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Heavy_Cb,
-				     Ecore_Thread_Notify_Cb,
+                                     Ecore_Thread_Notify_Cb,
                                      Ecore_Thread_End_Cb,
                                      Ecore_Thread_Cancel_Cb,
                                      const void *data,
@@ -364,22 +373,21 @@
    EAPI void          ecore_thread_max_reset(void);
    EAPI int           ecore_thread_available_get(void);
 
-   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key,
-           const void *value, Eina_Bool direct);
-   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key,
-           const void *value);
-   EAPI void         *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
+   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
+   EAPI Ecore_Thread_Data         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
+   EAPI const void   *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
-   EAPI void         *ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds);
+   EAPI const void   *ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds);
 
-   EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, const void *value,
-           Eina_Bool direct);
-   EAPI void         *ecore_thread_global_data_set(const char *key, const void *value);
-   EAPI void         *ecore_thread_global_data_find(const char *key);
+   EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
+   EAPI Ecore_Thread_Data         *ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb);
+   EAPI const void   *ecore_thread_global_data_find(const char *key);
    EAPI Eina_Bool     ecore_thread_global_data_del(const char *key);
-   EAPI void         *ecore_thread_global_data_wait(const char *key, double seconds);
+   EAPI const void   *ecore_thread_global_data_wait(const char *key, double seconds);
 
 
+
+
    EAPI double ecore_time_get(void);
    EAPI double ecore_loop_time_get(void);
 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-30 08:29:13 UTC (rev 50681)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-30 08:52:18 UTC (rev 50682)
@@ -74,7 +74,17 @@
 static pthread_rwlock_t _ecore_thread_global_hash_lock = PTHREAD_RWLOCK_INITIALIZER;
 static pthread_mutex_t _ecore_thread_global_hash_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t _ecore_thread_global_hash_cond = PTHREAD_COND_INITIALIZER;
+
 static void
+_ecore_thread_data_free(void *data)
+{
+   Ecore_Thread_Data *d = data;
+
+   if (d->cb) d->cb(d->data);
+   free(d);
+}
+
+static void
 _ecore_thread_pipe_free(void *data __UNUSED__, void *event)
 {
    Ecore_Pipe *p = event;
@@ -85,7 +95,7 @@
 static Eina_Bool
 _ecore_thread_pipe_del(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
 {
-   /* This is a hack to delay pipe destruction until we are out of it's internal loop. */
+   /* This is a hack to delay pipe destruction until we are out of its internal loop. */
    return ECORE_CALLBACK_CANCEL;
 }
 
@@ -835,9 +845,10 @@
  * functions to avoid leaks.
  */
 EAPI Eina_Bool
-ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, const void *value, Eina_Bool direct)
+ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   Ecore_Thread_Data *d;
    Eina_Bool ret;
 
    if ((!thread) || (!key) || (!value))
@@ -846,20 +857,23 @@
    if (worker->self != pthread_self()) return EINA_FALSE;
 
    if (!worker->hash)
-     worker->hash = eina_hash_string_small_new(NULL);
+     worker->hash = eina_hash_string_small_new(_ecore_thread_data_free);
 
    if (!worker->hash)
      return EINA_FALSE;
+
+   if (!(d = malloc(sizeof(Ecore_Thread_Data))))
+     return EINA_FALSE;
+
+   d->data = value;
+   d->cb = cb;
+
    if (direct)
-     ret = eina_hash_direct_add(worker->hash, key, value);
+     ret = eina_hash_direct_add(worker->hash, key, d);
    else
-     ret = eina_hash_add(worker->hash, key, value);
+     ret = eina_hash_add(worker->hash, key, d);
    pthread_cond_broadcast(&worker->cond);
    return ret;
-
-   if (direct)
-     return eina_hash_direct_add(worker->hash, key, value);
-   return eina_hash_add(worker->hash, key, value);
 #else
    return EINA_TRUE;
 #endif
@@ -877,23 +891,29 @@
  * All data added to the thread pool must be freed in the thread's func_end/func_cancel
  * functions to avoid leaks.
  */
-EAPI void *
-ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, const void *value)
+EAPI Ecore_Thread_Data *
+ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
-   void *ret;
+   Ecore_Thread_Data *d, *ret;
    if ((!thread) || (!key) || (!value))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
    if (worker->self != pthread_self()) return NULL;
 
    if (!worker->hash)
-     worker->hash = eina_hash_string_small_new(NULL);
+     worker->hash = eina_hash_string_small_new(_ecore_thread_data_free);
 
    if (!worker->hash)
      return NULL;
 
-   ret = eina_hash_set(worker->hash, key, value);
+   if (!(d = malloc(sizeof(Ecore_Thread_Data))))
+     return NULL;
+
+   d->data = value;
+   d->cb = cb;
+
+   ret = eina_hash_set(worker->hash, key, d);
    pthread_cond_broadcast(&worker->cond);
    return ret;
 #else
@@ -911,10 +931,12 @@
  * in any case but success.
  */
 
-EAPI void *
+EAPI const void *
 ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   Ecore_Thread_Data *d;
+
    if ((!thread) || (!key))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
@@ -923,7 +945,8 @@
    if (!worker->hash)
      return NULL;
 
-   return eina_hash_find(worker->hash, key);
+   d = eina_hash_find(worker->hash, key);
+   return d->data;
 #else
    return NULL;
 #endif
@@ -942,6 +965,7 @@
 ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
+   Ecore_Thread_Data *d;
    if ((!thread) || (!key))
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
@@ -949,7 +973,8 @@
 
    if (!worker->hash)
      return EINA_FALSE;
-
+   if ((d = eina_hash_find(worker->hash, key)))
+     _ecore_thread_data_free(d);
    return eina_hash_del_by_key(worker->hash, key);
 #else
    return EINA_TRUE;
@@ -966,11 +991,11 @@
  * This function will return NULL in any case but success.
  * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
  */
-EAPI void *
+EAPI const void *
 ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds)
 {
    double time = 0;
-   void *ret;
+   Ecore_Thread_Data *ret;
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    if ((!thread) || (!key))
      return NULL;
@@ -988,7 +1013,8 @@
         pthread_cond_wait(&worker->cond, &worker->mutex);
         pthread_mutex_unlock(&worker->mutex);
      }
-   return ret;
+   if (ret) return ret->data;
+   return NULL;
 #else
    return NULL;
 #endif
@@ -999,30 +1025,40 @@
  * @brief Add data to the global data
  * @param key The name string to add the data with
  * @param value The data to add
+ * @param cb The optional callback to free the data with once ecore is shut down
  * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
  * @return EINA_TRUE on success, EINA_FALSE on failure
  * This adds data to the global thread data, and will return EINA_FALSE in any case but success.
- * All data added to global should be manually freed to avoid stale pointers in the global thread data.
+ * All data added to global can be manually freed, or a callback can be provided with @p cb which will
+ * be called upon ecore_thread shutting down.
  */
 EAPI Eina_Bool
-ecore_thread_global_data_add(const char *key, const void *value, Eina_Bool direct)
+ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct)
 {
    Eina_Bool ret;
+   Ecore_Thread_Data *d;
+
    if ((!key) || (!value))
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
    if (!_ecore_thread_global_hash)
-     _ecore_thread_global_hash = eina_hash_string_small_new(NULL);
+     _ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
 
+   if (!(d = malloc(sizeof(Ecore_Thread_Data))))
+     return EINA_FALSE;
+
+   d->data = value;
+   d->cb = cb;
+
    if (!_ecore_thread_global_hash)
      return EINA_FALSE;
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
    if (direct)
-     ret = eina_hash_direct_add(_ecore_thread_global_hash, key, value);
+     ret = eina_hash_direct_add(_ecore_thread_global_hash, key, d);
    else
-     ret = eina_hash_add(_ecore_thread_global_hash, key, value);
+     ret = eina_hash_add(_ecore_thread_global_hash, key, d);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
    pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
    return ret;
@@ -1035,31 +1071,41 @@
  * @brief Add data to the global data
  * @param key The name string to add the data with
  * @param value The data to add
- * @return EINA_TRUE on success, EINA_FALSE on failure
+ * @param cb The optional callback to free the data with once ecore is shut down
+ * @return An @ref Ecore_Thread_Data on success, NULL on failure
  * This adds data to the global thread data and returns NULL, or replaces the previous data
  * associated with @p key and returning the previous data if it existed.  To see if an error occurred,
  * one must use eina_error_get.
- * All data added to global should be manually freed to avoid stale pointers in the global thread data.
+ * All data added to global can be manually freed, or a callback can be provided with @p cb which will
+ * be called upon ecore_thread shutting down.
  */
-EAPI void *
-ecore_thread_global_data_set(const char *key, const void *value)
+EAPI Ecore_Thread_Data *
+ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb)
 {
-   void *ret;
+   Ecore_Thread_Data *d, *ret;
+
    if ((!key) || (!value))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
    if (!_ecore_thread_global_hash)
-     _ecore_thread_global_hash = eina_hash_string_small_new(NULL);
+     _ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
 
    if (!_ecore_thread_global_hash)
      return NULL;
 
+   if (!(d = malloc(sizeof(Ecore_Thread_Data))))
+     return NULL;
+
+   d->data = value;
+   d->cb = cb;
+
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
-   ret = eina_hash_set(_ecore_thread_global_hash, key, value);
+   ret = eina_hash_set(_ecore_thread_global_hash, key, d);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
    pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
+
    return ret;
 #else
    return NULL;
@@ -1074,10 +1120,10 @@
  * This function will return NULL in any case but success.
  */
 
-EAPI void *
+EAPI const void *
 ecore_thread_global_data_find(const char *key)
 {
-   void *ret;
+   Ecore_Thread_Data *ret;
    if (!key)
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
@@ -1086,7 +1132,7 @@
    pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
    ret = eina_hash_find(_ecore_thread_global_hash, key);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
-   return ret;
+   return ret->data;
 #else
    return NULL;
 #endif
@@ -1098,12 +1144,14 @@
  * @return EINA_TRUE on success, EINA_FALSE on failure
  * This deletes the data pointer from the global data which was previously added with @ref ecore_thread_global_data_add
  * This function will return EINA_FALSE in any case but success.
- * Note that this WILL NOT free the data, it merely removes it from the global set.
+ * Note that this WILL free the data if an @c Eina_Free_Cb was specified when the data was added.
  */
 EAPI Eina_Bool
 ecore_thread_global_data_del(const char *key)
 {
    Eina_Bool ret;
+   Ecore_Thread_Data *d;
+
    if (!key)
      return EINA_FALSE;
 #ifdef EFL_HAVE_PTHREAD
@@ -1111,6 +1159,8 @@
      return EINA_FALSE;
 
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
+   if ((d = eina_hash_find(_ecore_thread_global_hash, key)))
+     _ecore_thread_data_free(d);
    ret = eina_hash_del_by_key(_ecore_thread_global_hash, key);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
    return ret;
@@ -1129,11 +1179,11 @@
  * This function will return NULL in any case but success.
  * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
  */
-EAPI void *
+EAPI const void *
 ecore_thread_global_data_wait(const char *key, double seconds)
 {
    double time = 0;
-   void *ret = NULL;
+   Ecore_Thread_Data *ret = NULL;
    if (!key)
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
@@ -1153,7 +1203,8 @@
         pthread_cond_wait(&_ecore_thread_global_hash_cond, &_ecore_thread_global_hash_mutex);
         pthread_mutex_unlock(&_ecore_thread_global_hash_mutex);
      }
-   return ret;
+   if (ret) return ret->data;
+   return NULL;
 #else
    return NULL;
 #endif

Log:
  remove ecore_thread_pool_data_wait, make thread data struct private again, return void* on _set(), fix global_wait to not mutex longer than wait time when no data added
  
Author:       discomfitor
Date:         2010-07-30 08:56:18 -0700 (Fri, 30 Jul 2010)
New Revision: 50687

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-07-30 11:34:08 UTC (rev 50686)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-07-30 15:56:18 UTC (rev 50687)
@@ -167,12 +167,6 @@
    typedef struct _Ecore_Exe_Event_Data_Line   Ecore_Exe_Event_Data_Line; /**< Lines from a child process */
    typedef struct _Ecore_Exe_Event_Data        Ecore_Exe_Event_Data; /**< Data from a child process */
 
-
-   typedef struct _Ecore_Thread_Data
-   {
-      void *data;
-      Eina_Free_Cb cb;
-   } Ecore_Thread_Data;
    typedef struct _Ecore_Thread                Ecore_Thread;
    typedef void (*Ecore_Thread_Blocking_Cb) (void *data);
    typedef void (*Ecore_Thread_End_Cb) (void *data);
@@ -374,13 +368,12 @@
    EAPI int           ecore_thread_available_get(void);
 
    EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
-   EAPI Ecore_Thread_Data         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
+   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
    EAPI const void   *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
    EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
-   EAPI const void   *ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds);
 
    EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
-   EAPI Ecore_Thread_Data         *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);
    EAPI const void   *ecore_thread_global_data_find(const char *key);
    EAPI Eina_Bool     ecore_thread_global_data_del(const char *key);
    EAPI const void   *ecore_thread_global_data_wait(const char *key, double seconds);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-30 11:34:08 UTC (rev 50686)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-07-30 15:56:18 UTC (rev 50687)
@@ -15,7 +15,14 @@
 
 typedef struct _Ecore_Pthread_Worker Ecore_Pthread_Worker;
 typedef struct _Ecore_Pthread Ecore_Pthread;
+typedef struct _Ecore_Thread_Data  Ecore_Thread_Data;
 
+struct _Ecore_Thread_Data
+{
+   void *data;
+   Eina_Free_Cb cb;
+};
+
 struct _Ecore_Pthread_Worker
 {
    union
@@ -891,11 +898,12 @@
  * All data added to the thread pool must be freed in the thread's func_end/func_cancel
  * functions to avoid leaks.
  */
-EAPI Ecore_Thread_Data *
+EAPI void *
 ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
-   Ecore_Thread_Data *d, *ret;
+   Ecore_Thread_Data *d, *r;
+   void *ret;
    if ((!thread) || (!key) || (!value))
      return NULL;
 #ifdef EFL_HAVE_PTHREAD
@@ -913,8 +921,10 @@
    d->data = value;
    d->cb = cb;
 
-   ret = eina_hash_set(worker->hash, key, d);
+   r = eina_hash_set(worker->hash, key, d);
    pthread_cond_broadcast(&worker->cond);
+   ret = r->data;
+   free(r);
    return ret;
 #else
    return NULL;
@@ -982,46 +992,6 @@
 }
 
 /**
- * @brief Find data in the pool data and optionally wait for the data if not found
- * @param key The name string the data is associated with
- * @param seconds The amount of time in seconds to wait for the data.  If 0, the call will be async and not wait for data.
- * If < 0 the call will wait indefinitely for the data.
- * @return The value, or NULL on failure
- * This finds data in the pool data that has been previously added with @ref ecore_thread_pool_data_add
- * This function will return NULL in any case but success.
- * Use @p seconds to specify the amount of time to wait.  Use > 0 for an actual wait time, 0 to not wait, and < 0 to wait indefinitely.
- */
-EAPI const void *
-ecore_thread_pool_data_wait(Ecore_Thread *thread, const char *key, double seconds)
-{
-   double time = 0;
-   Ecore_Thread_Data *ret;
-   Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
-   if ((!thread) || (!key))
-     return NULL;
-#ifdef EFL_HAVE_PTHREAD
-   if (worker->self != pthread_self()) return NULL;
-   if (seconds > 0)
-     time = ecore_time_get() + seconds;
-
-   while (1)
-     {
-        ret = eina_hash_find(worker->hash, key);
-        if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
-          break;
-        pthread_mutex_lock(&worker->mutex);
-        pthread_cond_wait(&worker->cond, &worker->mutex);
-        pthread_mutex_unlock(&worker->mutex);
-     }
-   if (ret) return ret->data;
-   return NULL;
-#else
-   return NULL;
-#endif
-}
-
-
-/**
  * @brief Add data to the global data
  * @param key The name string to add the data with
  * @param value The data to add
@@ -1079,10 +1049,11 @@
  * All data added to global can be manually freed, or a callback can be provided with @p cb which will
  * be called upon ecore_thread shutting down.
  */
-EAPI Ecore_Thread_Data *
+EAPI void *
 ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb)
 {
-   Ecore_Thread_Data *d, *ret;
+   Ecore_Thread_Data *d, *r;
+   void *ret;
 
    if ((!key) || (!value))
      return NULL;
@@ -1102,10 +1073,12 @@
    d->cb = cb;
 
    pthread_rwlock_wrlock(&_ecore_thread_global_hash_lock);
-   ret = eina_hash_set(_ecore_thread_global_hash, key, d);
+   r = eina_hash_set(_ecore_thread_global_hash, key, d);
    pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
    pthread_cond_broadcast(&_ecore_thread_global_hash_cond);
 
+   ret = r->data;
+   free(r);
    return ret;
 #else
    return NULL;
@@ -1194,13 +1167,17 @@
 
    while (1)
      {
+        struct timespec t = {0};
+
+        t.tv_sec = (long int)time;
+        t.tv_nsec = (long int)((time - (double)t.tv_sec) * 1000000000);
         pthread_rwlock_rdlock(&_ecore_thread_global_hash_lock);
         ret = eina_hash_find(_ecore_thread_global_hash, key);
         pthread_rwlock_unlock(&_ecore_thread_global_hash_lock);
         if ((ret) || (!seconds) || ((seconds > 0) && (time <= ecore_time_get())))
           break;
         pthread_mutex_lock(&_ecore_thread_global_hash_mutex);
-        pthread_cond_wait(&_ecore_thread_global_hash_cond, &_ecore_thread_global_hash_mutex);
+        pthread_cond_timedwait(&_ecore_thread_global_hash_cond, &_ecore_thread_global_hash_mutex, &t);
         pthread_mutex_unlock(&_ecore_thread_global_hash_mutex);
      }
    if (ret) return ret->data;

Log:
  fix random value generator.
  SPANK SPANK SPANK!!!
  
Author:       discomfitor
Date:         2010-08-02 12:36:37 -0700 (Mon, 02 Aug 2010)
New Revision: 50750

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-02 19:14:52 UTC (rev 50749)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-02 19:36:37 UTC (rev 50750)
@@ -486,7 +486,7 @@
 ecore_thread_cancel(Ecore_Thread *thread)
 {
 #ifdef EFL_HAVE_PTHREAD
-   Ecore_Pthread_Worker *work;
+   Ecore_Pthread_Worker *work = (Ecore_Pthread_Worker*) thread;
    Eina_List *l;
 
    if (!work)

Log:
  convert all function pointers to typedefs, add doxy stubs for typedefs.
  note: I've chosen to consolidate typedefs where possible to simplify things
  
  my time is limited this week, so feel free to expand on the doxy stubs I've added if you know what they do
  
Author:       discomfitor
Date:         2010-08-03 19:55:20 -0700 (Tue, 03 Aug 2010)
New Revision: 50803

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_anim.c trunk/ecore/src/lib/ecore/ecore_events.c trunk/ecore/src/lib/ecore/ecore_exe.c trunk/ecore/src/lib/ecore/ecore_exe_win32.c trunk/ecore/src/lib/ecore/ecore_glib.c trunk/ecore/src/lib/ecore/ecore_idle_enterer.c trunk/ecore/src/lib/ecore/ecore_idle_exiter.c trunk/ecore/src/lib/ecore/ecore_idler.c trunk/ecore/src/lib/ecore/ecore_job.c trunk/ecore/src/lib/ecore/ecore_main.c trunk/ecore/src/lib/ecore/ecore_pipe.c trunk/ecore/src/lib/ecore/ecore_poll.c trunk/ecore/src/lib/ecore/ecore_private.h trunk/ecore/src/lib/ecore/ecore_thread.c trunk/ecore/src/lib/ecore/ecore_timer.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-08-04 02:55:20 UTC (rev 50803)
@@ -166,16 +166,80 @@
    typedef struct _Ecore_Exe_Event_Del         Ecore_Exe_Event_Del; /**< Spawned Exe exit event */
    typedef struct _Ecore_Exe_Event_Data_Line   Ecore_Exe_Event_Data_Line; /**< Lines from a child process */
    typedef struct _Ecore_Exe_Event_Data        Ecore_Exe_Event_Data; /**< Data from a child process */
+   typedef struct _Ecore_Thread                Ecore_Thread;
 
-   typedef struct _Ecore_Thread                Ecore_Thread;
-   typedef void (*Ecore_Thread_Blocking_Cb) (void *data);
-   typedef void (*Ecore_Thread_End_Cb) (void *data);
-   typedef void (*Ecore_Thread_Cancel_Cb) (void *data);
+   /**
+    * @typedef Ecore_Data_Cb Ecore_Data_Cb
+    * A callback which is used to return data to the main function
+    */
+   typedef void *(*Ecore_Data_Cb) (void *data);
+   /**
+    * @typedef Ecore_Filter_Cb
+    * A callback used for filtering events from the main loop.
+    */
+   typedef Eina_Bool (*Ecore_Filter_Cb) (void *data, void *loop_data, int type, void *event);
+   /**
+    * @typedef Ecore_Eselect_Function Ecore_Eselect_Function
+    * A function which can be used to replace select() in the main loop
+    */
+   typedef int (*Ecore_Select_Function)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+   /**
+    * @typedef Ecore_End_Cb Ecore_End_Cb
+    * This is the callback which is called at the end of a function, usually for cleanup purposes.
+    */
+   typedef void (*Ecore_End_Cb) (void *user_data, void *func_data);
+   /**
+    * @typedef Ecore_Pipe_Cb Ecore_Pipe_Cb
+    * The callback that data written to the pipe is sent to.
+    */
+   typedef void (*Ecore_Pipe_Cb) (void *data, void *buffer, unsigned int nbyte);
+   /**
+    * @typedef Ecore_Exe_Cb Ecore_Exe_Cb
+    * A callback to run with the associated @ref Ecore_Exe, usually for cleanup purposes.
+    */
+   typedef void (*Ecore_Exe_Cb)(void *data, const Ecore_Exe *exe);
+   /**
+    * @typedef Ecore_Event_Handler_Cb Ecore_Event_Handler_Cb
+    * A callback used by the main loop to handle events of a specified type.
+    */
+   typedef Eina_Bool (*Ecore_Event_Handler_Cb) (void *data, int type, void *event);
+   /**
+    * @typedef Ecore_Thread_Heavy_Cb Ecore_Thread_Heavy_Cb
+    * A callback used to run cpu intensive or blocking I/O operations.
+    */
    typedef void (*Ecore_Thread_Heavy_Cb) (Ecore_Thread *thread, void *data);
+   /**
+    * @typedef Ecore_Thread_Notify_Cb Ecore_Thread_Notify_Cb
+    * A callback used by the main loop to receive data sent by an @ref Ecore_Thread.
+    */
    typedef void (*Ecore_Thread_Notify_Cb) (Ecore_Thread *thread, void *msg_data, void *data);
+   /**
+    * @typedef Ecore_Task_Cb Ecore_Task_Cb
+    * A callback run for a task (timer, idler, poller, animater, etc)
+    */
+   typedef Eina_Bool (*Ecore_Task_Cb) (void *data);
+   /**
+    * @typedef Ecore_Cb Ecore_Cb
+    * A generic callback called as a hook when a certain point in execution is reached.
+    */
+   typedef void (*Ecore_Cb) (void *data);
+   /**
+    * @typedef Ecore_Fd_Cb Ecore_Fd_Cb
+    * A callback used by an @ref Ecore_Fd_Handler.
+    */
+   typedef Eina_Bool (*Ecore_Fd_Cb) (void *data, Ecore_Fd_Handler *fd_handler);
+   /**
+    * @typedef Ecore_Fd_Prep_Cb Ecore_Fd_Prep_Cb
+    * A callback used by an @ref Ecore_Fd_Handler.
+    */
+   typedef void (*Ecore_Fd_Prep_Cb) (void *data, Ecore_Fd_Handler *fd_handler);
+   /**
+    * @typedef Ecore_Fd_Win32_Cb Ecore_Fd_Win32_Cb
+    * A callback used by an @ref Ecore_Win32_Handler.
+    */
+   typedef Eina_Bool (*Ecore_Fd_Win32_Cb) (void *data, Ecore_Win32_Handler *wh);
 
 
-
    typedef struct _Ecore_Job Ecore_Job; /**< A job handle */
 
    struct _Ecore_Event_Signal_User /** User signal event */
@@ -268,12 +332,12 @@
    EAPI void ecore_app_args_get(int *argc, char ***argv);
    EAPI void ecore_app_restart(void);
 
-   EAPI Ecore_Event_Handler *ecore_event_handler_add(int type, Eina_Bool (*func) (void *data, int type, void *event), const void *data);
+   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, void (*func_free) (void *data, void *ev), void *data);
+   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 int                  ecore_event_type_new(void);
-   EAPI Ecore_Event_Filter  *ecore_event_filter_add(void * (*func_start) (void *data), Eina_Bool (*func_filter) (void *data, void *loop_data, int type, void *event), void (*func_end) (void *data, void *loop_data), const void *data);
+   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);
@@ -283,7 +347,7 @@
    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, void (*func)(void *data, const Ecore_Exe *exe));
+   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);
@@ -305,19 +369,19 @@
    EAPI void        ecore_exe_signal(Ecore_Exe *exe, int num);
    EAPI void        ecore_exe_hup(Ecore_Exe *exe);
 
-   EAPI Ecore_Idler *ecore_idler_add(Eina_Bool (*func) (void *data), const void *data);
+   EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
    EAPI void        *ecore_idler_del(Ecore_Idler *idler);
 
-   EAPI Ecore_Idle_Enterer *ecore_idle_enterer_add(Eina_Bool (*func) (void *data), const void *data);
-   EAPI Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Eina_Bool (*func) (void *data), const void *data);
+   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(Eina_Bool (*func) (void *data), const void *data);
+   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 void              ecore_main_loop_iterate(void);
 
-   EAPI void              ecore_main_loop_select_func_set(int (*func)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout));
+   EAPI void              ecore_main_loop_select_func_set(Ecore_Select_Function func);
    EAPI void             *ecore_main_loop_select_func_get(void);
 
    EAPI Eina_Bool         ecore_main_loop_glib_integrate(void);
@@ -325,19 +389,18 @@
        
    EAPI void              ecore_main_loop_begin(void);
    EAPI void              ecore_main_loop_quit(void);
-   EAPI Ecore_Fd_Handler *ecore_main_fd_handler_add(int fd, Ecore_Fd_Handler_Flags flags,
-						    Eina_Bool (*func) (void *data, Ecore_Fd_Handler *fd_handler), const void *data,
-						    Eina_Bool (*buf_func) (void *buf_data, Ecore_Fd_Handler *fd_handler), const void *buf_data);
-   EAPI void              ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, void (*func) (void *data, Ecore_Fd_Handler *fd_handler), const void *data);
+   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 int               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, Eina_Bool (*func) (void *data, Ecore_Win32_Handler *wh), const void *data);
+   EAPI Ecore_Win32_Handler *ecore_main_win32_handler_add(void *h, Ecore_Fd_Win32_Cb func, const void *data);
    EAPI void                *ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler);
 
-   EAPI Ecore_Pipe  *ecore_pipe_add(void (*handler) (void *data, void *buffer, unsigned int nbyte), const void *data);
+   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);
@@ -345,14 +408,14 @@
 
 
 
-   EAPI Ecore_Thread *ecore_thread_run(Ecore_Thread_Blocking_Cb,
-                                       Ecore_Thread_End_Cb,
-                                       Ecore_Thread_Cancel_Cb,
+   EAPI Ecore_Thread *ecore_thread_run(Ecore_Cb,
+                                       Ecore_Cb,
+                                       Ecore_Cb,
                                        const void *data);
    EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Heavy_Cb,
                                      Ecore_Thread_Notify_Cb,
-                                     Ecore_Thread_End_Cb,
-                                     Ecore_Thread_Cancel_Cb,
+                                     Ecore_Cb,
+                                     Ecore_Cb,
                                      const void *data,
                                      Eina_Bool try_no_queue);
    EAPI Eina_Bool     ecore_thread_cancel(Ecore_Thread *thread);
@@ -384,8 +447,8 @@
    EAPI double ecore_time_get(void);
    EAPI double ecore_loop_time_get(void);
 
-   EAPI Ecore_Timer *ecore_timer_add(double in, Eina_Bool (*func) (void *data), const void *data);
-   EAPI Ecore_Timer *ecore_timer_loop_add(double in, Eina_Bool (*func) (void *data), const void *data);
+   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);
@@ -397,7 +460,7 @@
    EAPI double       ecore_timer_precision_get(void);
    EAPI void         ecore_timer_precision_set(double precision);
 
-   EAPI Ecore_Animator *ecore_animator_add(Eina_Bool (*func) (void *data), const void *data);
+   EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
    EAPI void           *ecore_animator_del(Ecore_Animator *animator);
    EAPI void		ecore_animator_freeze(Ecore_Animator *animator);
    EAPI void		ecore_animator_thaw(Ecore_Animator *animator);
@@ -408,10 +471,10 @@
    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, Eina_Bool (*func) (void *data), const void *data);
+   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);
 
-   EAPI Ecore_Job *ecore_job_add(void (*func) (void *data), const void *data);
+   EAPI Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
    EAPI void      *ecore_job_del(Ecore_Job *job);
 
 #ifdef __cplusplus

Modified: trunk/ecore/src/lib/ecore/ecore_anim.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_anim.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_anim.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -18,7 +18,7 @@
    EINA_INLIST;
    ECORE_MAGIC;
 
-   Eina_Bool    (*func) (void *data);
+   Ecore_Task_Cb func;
    void          *data;
 
    Eina_Bool     delete_me : 1;
@@ -51,7 +51,7 @@
  * automatically making any references/handles for it invalid.
  */
 EAPI Ecore_Animator *
-ecore_animator_add(Eina_Bool (*func) (void *data), const void *data)
+ecore_animator_add(Ecore_Task_Cb func, const void *data)
 {
    Ecore_Animator *animator;
 

Modified: trunk/ecore/src/lib/ecore/ecore_events.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_events.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_events.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -18,7 +18,7 @@
    EINA_INLIST;
    ECORE_MAGIC;
    int type;
-   Eina_Bool (*func) (void *data, int type, void *event);
+   Ecore_Event_Handler_Cb func;
    void *data;
    int       references;
    Eina_Bool delete_me : 1;
@@ -28,9 +28,9 @@
 {
    EINA_INLIST;
    ECORE_MAGIC;
-   void *(*func_start) (void *data);
-   Eina_Bool (*func_filter) (void *data, void *loop_data, int type, void *event);
-   void (*func_end) (void *data, void *loop_data);
+   Ecore_Data_Cb func_start;
+   Ecore_Filter_Cb func_filter;
+   Ecore_End_Cb func_end;
    void *loop_data;
    void *data;
    int       references;
@@ -43,7 +43,7 @@
    ECORE_MAGIC;
    int type;
    void *event;
-   void (*func_free) (void *data, void *ev);
+   Ecore_End_Cb func_free;
    void *data;
    int       references;
    Eina_Bool delete_me : 1;
@@ -98,7 +98,7 @@
  * been called, will not be.
  */
 EAPI Ecore_Event_Handler *
-ecore_event_handler_add(int type, Eina_Bool (*func) (void *data, int type, void *event), const void *data)
+ecore_event_handler_add(int type, Ecore_Event_Handler_Cb func, const void *data)
 {
    Ecore_Event_Handler *eh;
 
@@ -187,7 +187,7 @@
  * func_free is passed @p data as its data parameter.
  */
 EAPI Ecore_Event *
-ecore_event_add(int type, void *ev, void (*func_free) (void *data, void *ev), void *data)
+ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data)
 {
 /*   if (!ev) return NULL;*/
    if (type <= ECORE_EVENT_NONE) return NULL;
@@ -258,7 +258,7 @@
  * and @p data pointer to clean up.
  */
 EAPI Ecore_Event_Filter *
-ecore_event_filter_add(void * (*func_start) (void *data), Eina_Bool (*func_filter) (void *data, void *loop_data, int type, void *event), void (*func_end) (void *data, void *loop_data), const void *data)
+ecore_event_filter_add(Ecore_Data_Cb func_start, Ecore_Filter_Cb func_filter, Ecore_End_Cb func_end, const void *data)
 {
    Ecore_Event_Filter *ef;
 
@@ -382,7 +382,7 @@
 }
 
 Ecore_Event *
-_ecore_event_add(int type, void *ev, void (*func_free) (void *data, void *ev), void *data)
+_ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data)
 {
    Ecore_Event *e;
 

Modified: trunk/ecore/src/lib/ecore/ecore_exe.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_exe.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_exe.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -121,7 +121,7 @@
    Ecore_Timer *doomsday_clock; /* The Timer of Death.  Muahahahaha. */
    void *doomsday_clock_dead; /* data for the doomsday clock */
 
-   void (*pre_free_cb)(void *data, const Ecore_Exe *exe);
+   Ecore_Exe_Cb pre_free_cb;
 };
 
 
@@ -712,7 +712,7 @@
  * @param func The function to call before @a exe is freed.
  */
 EAPI void
-ecore_exe_callback_pre_free_set(Ecore_Exe *exe, void (*func)(void *data, const Ecore_Exe *exe))
+ecore_exe_callback_pre_free_set(Ecore_Exe *exe, Ecore_Exe_Cb func)
 {
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
      {

Modified: trunk/ecore/src/lib/ecore/ecore_exe_win32.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_exe_win32.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_exe_win32.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -82,7 +82,7 @@
    Eina_Bool    close_stdin : 1;
    Eina_Bool    is_suspended : 1;
 
-   void (*pre_free_cb)(void *data, const Ecore_Exe *exe);
+   Ecore_Exe_Cb pre_free_cb;
 };
 
 static Ecore_Exe *exes = NULL;
@@ -292,7 +292,7 @@
 }
 
 EAPI void
-ecore_exe_callback_pre_free_set(Ecore_Exe *exe, void (*func)(void *data, const Ecore_Exe *exe))
+ecore_exe_callback_pre_free_set(Ecore_Exe *exe, Ecore_Exe_Cb func)
 {
    if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
      {

Modified: trunk/ecore/src/lib/ecore/ecore_glib.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_glib.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_glib.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -15,7 +15,7 @@
 #include <glib.h>
 
 static Eina_Bool _ecore_glib_active = EINA_FALSE;
-static int (*_ecore_glib_select_original)(int, fd_set*, fd_set*, fd_set*, struct timeval *);
+static Ecore_Select_Function _ecore_glib_select_original;
 static GCond *_ecore_glib_cond = NULL;
 static GPollFD *_ecore_glib_fds = NULL;
 static size_t _ecore_glib_fds_size = 0;

Modified: trunk/ecore/src/lib/ecore/ecore_idle_enterer.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_idle_enterer.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_idle_enterer.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -16,7 +16,7 @@
 {
    EINA_INLIST;
    ECORE_MAGIC;
-   Eina_Bool  (*func) (void *data);
+   Ecore_Task_Cb func;
    void        *data;
    int          references;
    Eina_Bool    delete_me : 1;
@@ -36,7 +36,7 @@
  * @ingroup Idle_Group
  */
 EAPI Ecore_Idle_Enterer *
-ecore_idle_enterer_add(Eina_Bool (*func) (void *data), const void *data)
+ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data)
 {
    Ecore_Idle_Enterer *ie;
 
@@ -59,7 +59,7 @@
  * @ingroup Idle_Group
  */
 EAPI Ecore_Idle_Enterer *
-ecore_idle_enterer_before_add(Eina_Bool (*func) (void *data), const void *data)
+ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data)
 {
    Ecore_Idle_Enterer *ie;
 

Modified: trunk/ecore/src/lib/ecore/ecore_idle_exiter.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_idle_exiter.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_idle_exiter.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -16,7 +16,7 @@
 {
    EINA_INLIST;
    ECORE_MAGIC;
-   Eina_Bool  (*func) (void *data);
+   Ecore_Task_Cb func;
    void        *data;
    int          references;
    Eina_Bool    delete_me : 1;
@@ -35,7 +35,7 @@
  * @ingroup Idle_Group
  */
 EAPI Ecore_Idle_Exiter *
-ecore_idle_exiter_add(Eina_Bool (*func) (void *data), const void *data)
+ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data)
 {
    Ecore_Idle_Exiter *ie;
 

Modified: trunk/ecore/src/lib/ecore/ecore_idler.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_idler.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_idler.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -16,7 +16,7 @@
 {
    EINA_INLIST;
    ECORE_MAGIC;
-   Eina_Bool  (*func) (void *data);
+   Ecore_Task_Cb func;
    void        *data;
    int          references;
    Eina_Bool    delete_me : 1;
@@ -43,7 +43,7 @@
  * Idlers are useful for progressively prossessing data without blocking.
  */
 EAPI Ecore_Idler *
-ecore_idler_add(Eina_Bool (*func) (void *data), const void *data)
+ecore_idler_add(Ecore_Task_Cb func, const void *data)
 {
    Ecore_Idler *ie;
 

Modified: trunk/ecore/src/lib/ecore/ecore_job.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_job.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_job.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -21,7 +21,7 @@
 {
    ECORE_MAGIC;
    Ecore_Event  *event;
-   void        (*func) (void *data);
+   Ecore_Cb func;
    void         *data;
 };
 
@@ -50,7 +50,7 @@
  * @note    Once the job has been executed, the job handle is invalid.
  */
 EAPI Ecore_Job *
-ecore_job_add(void (*func) (void *data), const void *data)
+ecore_job_add(Ecore_Cb func, const void *data)
 {
    Ecore_Job *job;
    

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -63,11 +63,11 @@
    ECORE_MAGIC;
    int                      fd;
    Ecore_Fd_Handler_Flags   flags;
-   Eina_Bool              (*func) (void *data, Ecore_Fd_Handler *fd_handler);
+   Ecore_Fd_Cb              func;
    void                    *data;
-   Eina_Bool              (*buf_func) (void *data, Ecore_Fd_Handler *fd_handler);
+   Ecore_Fd_Cb              buf_func;
    void                    *buf_data;
-   void                   (*prep_func) (void *data, Ecore_Fd_Handler *fd_handler);
+   Ecore_Fd_Prep_Cb         prep_func;
    void                    *prep_data;
    int                      references;
    Eina_Bool                read_active : 1;
@@ -82,7 +82,7 @@
    EINA_INLIST;
    ECORE_MAGIC;
    HANDLE         h;
-   Eina_Bool    (*func) (void *data, Ecore_Win32_Handler *win32_handler);
+   Ecore_Fd_Win32_Cb func;
    void          *data;
    int            references;
    Eina_Bool      delete_me : 1;
@@ -117,9 +117,9 @@
 #endif
 
 #ifdef _WIN32
-static int (*main_loop_select)(int , fd_set *, fd_set *, fd_set *, struct timeval *) = _ecore_main_win32_select;
+static Ecore_Select_Function main_loop_select = _ecore_main_win32_select;
 #else
-static int (*main_loop_select)(int , fd_set *, fd_set *, fd_set *, struct timeval *) = select;
+static Ecore_Select_Function main_loop_select = select;
 #endif
 
 static double            t1 = 0.0;
@@ -306,7 +306,7 @@
  * @ingroup Ecore_Main_Loop_Group
  */
 EAPI void
-ecore_main_loop_select_func_set(int (*func) (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout))
+ecore_main_loop_select_func_set(Ecore_Select_Function func)
 {
    main_loop_select = func;
 }
@@ -362,9 +362,8 @@
  * @ingroup Ecore_FD_Handler_Group
  */
 EAPI Ecore_Fd_Handler *
-ecore_main_fd_handler_add(int fd, Ecore_Fd_Handler_Flags flags,
-			  Eina_Bool (*func) (void *data, Ecore_Fd_Handler *fd_handler), const void *data,
-			  Eina_Bool (*buf_func) (void *buf_data, Ecore_Fd_Handler *fd_handler), const void *buf_data)
+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)
 {
    Ecore_Fd_Handler *fdh;
 
@@ -397,9 +396,7 @@
 
 #ifdef _WIN32
 EAPI Ecore_Win32_Handler *
-ecore_main_win32_handler_add(void *h,
-                             Eina_Bool (*func) (void *data, Ecore_Win32_Handler *wh),
-                             const void *data)
+ecore_main_win32_handler_add(void *h, Ecore_Fd_Win32_Cb func, const void *data)
 {
    Ecore_Win32_Handler *wh;
 
@@ -419,8 +416,7 @@
 }
 #else
 EAPI Ecore_Win32_Handler *
-ecore_main_win32_handler_add(void *h __UNUSED__,
-                             Eina_Bool (*func) (void *data, Ecore_Win32_Handler *wh) __UNUSED__,
+ecore_main_win32_handler_add(void *h __UNUSED__, Ecore_Fd_Win32_Cb func __UNUSED__,
                              const void *data __UNUSED__)
 {
    return NULL;
@@ -477,7 +473,7 @@
 #endif
 
 EAPI void
-ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, void (*func) (void *data, Ecore_Fd_Handler *fd_handler), const void *data)
+ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Prep_Cb func, const void *data)
 {
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
      {

Modified: trunk/ecore/src/lib/ecore/ecore_pipe.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_pipe.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_pipe.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -59,7 +59,7 @@
    int               fd_write;
    Ecore_Fd_Handler *fd_handler;
    const void       *data;
-   void            (*handler) (void *data, void *buffer, unsigned int nbyte);
+   Ecore_Pipe_Cb     handler;
    unsigned int      len;
    size_t            already_read;
    void             *passed_data;
@@ -282,8 +282,7 @@
  * @ingroup Ecore_Pipe_Group
  */
 EAPI Ecore_Pipe *
-ecore_pipe_add(void (*handler) (void *data, void *buffer, unsigned int nbyte),
-               const void *data)
+ecore_pipe_add(Ecore_Pipe_Cb handler, const void *data)
 {
    Ecore_Pipe *p;
    int         fds[2];

Modified: trunk/ecore/src/lib/ecore/ecore_poll.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_poll.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_poll.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -18,7 +18,7 @@
    ECORE_MAGIC;
    int           ibit;
    unsigned char delete_me : 1;
-   Eina_Bool    (*func) (void *data);
+   Ecore_Task_Cb func;
    void          *data;
 };
 
@@ -282,7 +282,7 @@
  * invalid.
  */
 EAPI Ecore_Poller *
-ecore_poller_add(Ecore_Poller_Type type __UNUSED__, int interval, Eina_Bool (*func) (void *data), const void *data)
+ecore_poller_add(Ecore_Poller_Type type __UNUSED__, int interval, Ecore_Task_Cb func, const void *data)
 {
    Ecore_Poller *poller;
    int ibit;

Modified: trunk/ecore/src/lib/ecore/ecore_private.h
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_private.h	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_private.h	2010-08-04 02:55:20 UTC (rev 50803)
@@ -138,7 +138,7 @@
 
 void          _ecore_event_shutdown(void);
 int           _ecore_event_exist(void);
-Ecore_Event  *_ecore_event_add(int type, void *ev, void (*func_free) (void *data, void *ev), void *data);
+Ecore_Event  *_ecore_event_add(int type, void *ev, Ecore_End_Cb func_free, void *data);
 void          _ecore_event_call(void);
 
 Ecore_Timer  *_ecore_exe_doomsday_clock_get(Ecore_Exe *exe);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -29,18 +29,18 @@
      {
         struct
           {
-             void (*func_blocking)(void *data);
+             Ecore_Cb func_blocking;
            } short_run;
         struct
           {
-             void (*func_heavy)(Ecore_Thread *thread, void *data);
-             void (*func_notify)(Ecore_Thread *thread, void *msg_data, void *data);
+             Ecore_Thread_Heavy_Cb func_heavy;
+             Ecore_Thread_Notify_Cb func_notify;
              Ecore_Pipe *notify;
           } long_run;
      } u;
 
-    void (*func_cancel)(void *data);
-    void (*func_end)(void *data);
+    Ecore_Cb func_cancel;
+    Ecore_Cb func_end;
  #ifdef EFL_HAVE_PTHREAD
     pthread_t self;
     Eina_Hash *hash;
@@ -391,9 +391,9 @@
  * host CPU can handle.
  */
 EAPI Ecore_Thread *
-ecore_thread_run(Ecore_Thread_Blocking_Cb func_blocking,
-                 Ecore_Thread_End_Cb func_end,
-                 Ecore_Thread_Cancel_Cb func_cancel,
+ecore_thread_run(Ecore_Cb func_blocking,
+                 Ecore_Cb func_end,
+                 Ecore_Cb func_cancel,
                  const void *data)
 {
 #ifdef EFL_HAVE_PTHREAD
@@ -565,8 +565,8 @@
  */
 EAPI Ecore_Thread *ecore_long_run(Ecore_Thread_Heavy_Cb func_heavy,
                                   Ecore_Thread_Notify_Cb func_notify,
-                                  Ecore_Thread_End_Cb func_end,
-                                  Ecore_Thread_Cancel_Cb func_cancel,
+                                  Ecore_Cb func_end,
+                                  Ecore_Cb func_cancel,
                                   const void *data,
                                   Eina_Bool try_no_queue)
 {

Modified: trunk/ecore/src/lib/ecore/ecore_timer.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_timer.c	2010-08-04 02:18:44 UTC (rev 50802)
+++ trunk/ecore/src/lib/ecore/ecore_timer.c	2010-08-04 02:55:20 UTC (rev 50803)
@@ -20,7 +20,7 @@
    double          in;
    double          at;
    double          pending;
-   Eina_Bool     (*func) (void *data);
+   Ecore_Task_Cb   func;
    void           *data;
 
    int             references;
@@ -30,7 +30,7 @@
 };
 
 
-static void _ecore_timer_set(Ecore_Timer *timer, double at, double in, Eina_Bool (*func) (void *data), void *data);
+static void _ecore_timer_set(Ecore_Timer *timer, double at, double in, Ecore_Task_Cb func, void *data);
 
 static int          timers_added = 0;
 static int          timers_delete_me = 0;
@@ -113,7 +113,7 @@
  * invalid.
  */
 EAPI Ecore_Timer *
-ecore_timer_add(double in, Eina_Bool (*func) (void *data), const void *data)
+ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
 {
    double now;
    Ecore_Timer *timer;
@@ -142,7 +142,7 @@
  * ecore_timer_add() for more details.
  */
 EAPI Ecore_Timer *
-ecore_timer_loop_add(double in, Eina_Bool (*func) (void *data), const void *data)
+ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data)
 {
    double now;
    Ecore_Timer *timer;
@@ -568,7 +568,7 @@
 }
 
 static void
-_ecore_timer_set(Ecore_Timer *timer, double at, double in, Eina_Bool (*func) (void *data), void *data)
+_ecore_timer_set(Ecore_Timer *timer, double at, double in, Ecore_Task_Cb func, void *data)
 {
    Ecore_Timer *t2;

Log:
  ecore_thread_pool -> ecore_thread_local
  
Author:       discomfitor
Date:         2010-08-18 01:56:44 -0700 (Wed, 18 Aug 2010)
New Revision: 51272

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-08-18 07:35:25 UTC (rev 51271)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-08-18 08:56:44 UTC (rev 51272)
@@ -430,10 +430,10 @@
    EAPI void          ecore_thread_max_reset(void);
    EAPI int           ecore_thread_available_get(void);
 
-   EAPI Eina_Bool     ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
-   EAPI void         *ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb);
-   EAPI void   *ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key);
-   EAPI Eina_Bool     ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key);
+   EAPI Eina_Bool     ecore_thread_local_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
+   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_find(Ecore_Thread *thread, const char *key);
+   EAPI Eina_Bool     ecore_thread_local_data_del(Ecore_Thread *thread, const char *key);
 
    EAPI Eina_Bool     ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct);
    EAPI void         *ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb);

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-18 07:35:25 UTC (rev 51271)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-08-18 08:56:44 UTC (rev 51272)
@@ -845,22 +845,22 @@
 }
 
 /**
- * @brief Add data to the pool for subsequent uses
+ * @brief Add data to the thread for subsequent use
  * @param thread The thread context to add to
  * @param key The name string to add the data with
  * @param value The data to add
  * @param cb The callback to free the data with
  * @param direct If true, this will not copy the key string (like eina_hash_direct_add)
  * @return EINA_TRUE on success, EINA_FALSE on failure
- * This adds data to the thread context, allowing for subsequent users of the thread's pool
+ * This adds data to the thread context, allowing the thread
  * to retrieve and use it without complicated mutexing.  This function can only be called by a
  * *_run thread INSIDE the thread and will return EINA_FALSE in any case but success.
- * All data added to the thread pool will be freed with its associated callback (if present)
+ * All data added to the thread will be freed with its associated callback (if present)
  * upon thread termination.  If no callback is specified, it is expected that the user will free the
  * data, but this is most likely not what you want.
  */
 EAPI Eina_Bool
-ecore_thread_pool_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct)
+ecore_thread_local_data_add(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb, Eina_Bool direct)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    Ecore_Thread_Data *d;
@@ -895,7 +895,7 @@
 }
 
 /**
- * @brief Modify data in the pool, or add if not found
+ * @brief Modify data in the thread, or add if not found
  * @param thread The thread context
  * @param key The name string to add the data with
  * @param value The data to add
@@ -909,7 +909,7 @@
  * data, but this is most likely not what you want.
  */
 EAPI void *
-ecore_thread_pool_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb)
+ecore_thread_local_data_set(Ecore_Thread *thread, const char *key, void *value, Eina_Free_Cb cb)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    Ecore_Thread_Data *d, *r;
@@ -942,17 +942,17 @@
 }
 
 /**
- * @brief Find data in the pool's data
+ * @brief Find data in the thread's data
  * @param thread The thread context
  * @param key The name string the data is associated with
  * @return The value, or NULL on error
- * This finds data in the thread context that has been previously added with @ref ecore_thread_pool_data_add
+ * This finds data in the thread context that has been previously added with @ref ecore_thread_local_data_add
  * This function can only be called by a *_run thread INSIDE the thread, and will return NULL
  * in any case but success.
  */
 
 EAPI void *
-ecore_thread_pool_data_find(Ecore_Thread *thread, const char *key)
+ecore_thread_local_data_find(Ecore_Thread *thread, const char *key)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    Ecore_Thread_Data *d;
@@ -973,16 +973,16 @@
 }
 
 /**
- * @brief Delete data from the pool's data
+ * @brief Delete data from the thread's data
  * @param thread The thread context
  * @param key The name string the data is associated with
  * @return EINA_TRUE on success, EINA_FALSE on failure
- * This deletes the data pointer from the thread context which was previously added with @ref ecore_thread_pool_data_add
+ * This deletes the data pointer from the thread context which was previously added with @ref ecore_thread_local_data_add
  * This function can only be called by a *_run thread INSIDE the thread, and will return EINA_FALSE
  * in any case but success.  Note that this WILL free the data if a callback was specified.
  */
 EAPI Eina_Bool
-ecore_thread_pool_data_del(Ecore_Thread *thread, const char *key)
+ecore_thread_local_data_del(Ecore_Thread *thread, const char *key)
 {
    Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *) thread;
    Ecore_Thread_Data *d;

Log:
  ecore_main_fd_handler_active_get -> Eina_Bool
  
Author:       discomfitor
Date:         2010-09-20 19:06:41 -0700 (Mon, 20 Sep 2010)
New Revision: 52528

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-09-21 02:02:24 UTC (rev 52527)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-09-21 02:06:41 UTC (rev 52528)
@@ -394,7 +394,7 @@
    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 int               ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags);
+   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_Fd_Win32_Cb func, const void *data);

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-09-21 02:02:24 UTC (rev 52527)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-09-21 02:06:41 UTC (rev 52528)
@@ -746,24 +746,23 @@
  * @param   fd_handler The given FD handler.
  * @param   flags      The flags, @c ECORE_FD_READ, @c ECORE_FD_WRITE or
  *                     @c ECORE_FD_ERROR to query.
- * @return  @c 1 if any of the given flags are active. @c 0 otherwise.
+ * @return  #EINA_TRUE if any of the given flags are active. #EINA_FALSE otherwise.
  * @ingroup Ecore_FD_Handler_Group
  */
-EAPI int
+EAPI Eina_Bool
 ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags)
 {
-   int ret;
+   int ret = EINA_FALSE;
 
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
      {
 	ECORE_MAGIC_FAIL(fd_handler, ECORE_MAGIC_FD_HANDLER,
 			 "ecore_main_fd_handler_active_get");
-	return 0;
+	return EINA_FALSE;
      }
-   ret = 0;
-   if ((flags & ECORE_FD_READ) && (fd_handler->read_active)) ret = 1;
-   if ((flags & ECORE_FD_WRITE) && (fd_handler->write_active)) ret = 1;
-   if ((flags & ECORE_FD_ERROR) && (fd_handler->error_active)) ret = 1;
+   if ((flags & ECORE_FD_READ) && (fd_handler->read_active)) ret = EINA_TRUE;
+   if ((flags & ECORE_FD_WRITE) && (fd_handler->write_active)) ret = EINA_TRUE;
+   if ((flags & ECORE_FD_ERROR) && (fd_handler->error_active)) ret = EINA_TRUE;
    return ret;
 }

Log:
  remove unused variable
  
Author:       discomfitor
Date:         2010-09-20 19:16:40 -0700 (Mon, 20 Sep 2010)
New Revision: 52529

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2010-09-21 02:06:41 UTC (rev 52528)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2010-09-21 02:16:40 UTC (rev 52529)
@@ -241,7 +241,6 @@
 {
    struct sched_param param;
    int pol, prio, ret;
-   pid_t tid;
    pthread_t pthread_id;
 
    pthread_id = pthread_self();

Log:
  ++ecore_event_handler_data_{set,get}
  
Author:       discomfitor
Date:         2010-11-04 13:51:17 -0700 (Thu, 04 Nov 2010)
New Revision: 54162

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_events.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2010-11-04 19:57:21 UTC (rev 54161)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2010-11-04 20:51:17 UTC (rev 54162)
@@ -361,6 +361,8 @@
    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, 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);

Modified: trunk/ecore/src/lib/ecore/ecore_events.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_events.c	2010-11-04 19:57:21 UTC (rev 54161)
+++ trunk/ecore/src/lib/ecore/ecore_events.c	2010-11-04 20:51:17 UTC (rev 54162)
@@ -170,6 +170,45 @@
    return event_handler->data;
 }
 
+/**
+ * @brief Get the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @return The data
+ * This function returns the data previously associated with @p eh.
+ */
+EAPI void *
+ecore_event_handler_data_get(Ecore_Event_Handler *eh)
+{
+   if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
+     {
+        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_get");
+        return NULL;
+     }
+   return eh->data;
+}
+
+/**
+ * @brief Set the data associated with an #Ecore_Event_Handler
+ * @param eh The event handler
+ * @param data The data to associate
+ * @return The previous data
+ * This function sets @p data to @p eh and returns the old data pointer
+ * which was previously associated with @p eh.
+ */
+EAPI void *
+ecore_event_handler_data_set(Ecore_Event_Handler *eh, void *data)
+{
+   void *old;
+   if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
+     {
+        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_get");
+        return NULL;
+     }
+   old = eh->data;
+   eh->data = data;
+   return old;
+}
+
 static void
 _ecore_event_generic_free (void *data __UNUSED__, void *event)
 {

Log:
  typo fix
  
Author:       discomfitor
Date:         2010-11-05 19:59:11 -0700 (Fri, 05 Nov 2010)
New Revision: 54211

Modified:
  trunk/ecore/src/lib/ecore/ecore_events.c 

Modified: trunk/ecore/src/lib/ecore/ecore_events.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_events.c	2010-11-06 02:04:29 UTC (rev 54210)
+++ trunk/ecore/src/lib/ecore/ecore_events.c	2010-11-06 02:59:11 UTC (rev 54211)
@@ -201,7 +201,7 @@
    void *old;
    if (!ECORE_MAGIC_CHECK(eh, ECORE_MAGIC_EVENT_HANDLER))
      {
-        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_get");
+        ECORE_MAGIC_FAIL(eh, ECORE_MAGIC_EVENT_HANDLER, "ecore_event_handler_data_set");
         return NULL;
      }
    old = eh->data;

Log:
  add ecore_con strings
  
Author:       discomfitor
Date:         2010-11-06 10:06:56 -0700 (Sat, 06 Nov 2010)
New Revision: 54241

Modified:
  trunk/ecore/src/lib/ecore/ecore.c 

Modified: trunk/ecore/src/lib/ecore/ecore.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore.c	2010-11-06 17:04:09 UTC (rev 54240)
+++ trunk/ecore/src/lib/ecore/ecore.c	2010-11-06 17:06:56 UTC (rev 54241)
@@ -276,6 +276,15 @@
       case ECORE_MAGIC_EVENT:
         return "Ecore_Event (Event)";
         break;
+      case ECORE_MAGIC_CON_SERVER:
+        return "Ecore_Con_Server (Connection Server)";
+        break;
+      case ECORE_MAGIC_CON_CLIENT:
+        return "Ecore_Con_Client (Connection Client)";
+        break;
+      case ECORE_MAGIC_CON_URL:
+        return "Ecore_Con_Url (Connection Url)";
+        break;
       default:
         return "<UNKNOWN>";
      };

Log:
  I got overexcited
  
Author:       discomfitor
Date:         2010-11-06 10:54:01 -0700 (Sat, 06 Nov 2010)
New Revision: 54242

Modified:
  trunk/ecore/src/lib/ecore/ecore.c 

Modified: trunk/ecore/src/lib/ecore/ecore.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore.c	2010-11-06 17:06:56 UTC (rev 54241)
+++ trunk/ecore/src/lib/ecore/ecore.c	2010-11-06 17:54:01 UTC (rev 54242)
@@ -276,15 +276,6 @@
       case ECORE_MAGIC_EVENT:
         return "Ecore_Event (Event)";
         break;
-      case ECORE_MAGIC_CON_SERVER:
-        return "Ecore_Con_Server (Connection Server)";
-        break;
-      case ECORE_MAGIC_CON_CLIENT:
-        return "Ecore_Con_Client (Connection Client)";
-        break;
-      case ECORE_MAGIC_CON_URL:
-        return "Ecore_Con_Url (Connection Url)";
-        break;
       default:
         return "<UNKNOWN>";
      };

Log:
  should be bool since we already include eina
  
Author:       discomfitor
Date:         2010-11-12 10:37:27 -0800 (Fri, 12 Nov 2010)
New Revision: 54521

Modified:
  trunk/ecore/src/lib/ecore/Ecore_Getopt.h 

Modified: trunk/ecore/src/lib/ecore/Ecore_Getopt.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-12 18:24:59 UTC (rev 54520)
+++ trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-12 18:37:27 UTC (rev 54521)
@@ -161,7 +161,7 @@
      const char *copyright; /**< if exists, --copyright will work */
      const char *license; /**< if exists, --license will work */
      const char *description; /**< long description, possible multiline */
-     unsigned char strict : 1; /**< fail on errors */
+     Eina_Bool strict : 1; /**< fail on errors */
      const Ecore_Getopt_Desc descs[]; /* NULL terminated. */
   };

Log:
  unsigned char -> Eina_Bool cleanups; these files are in great need of documentation! if you know the code, please write help!
  
Author:       discomfitor
Date:         2010-11-13 04:01:55 -0800 (Sat, 13 Nov 2010)
New Revision: 54529

Modified:
  trunk/ecore/src/lib/ecore/Ecore_Getopt.h trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/Ecore_Getopt.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-13 09:37:15 UTC (rev 54528)
+++ trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-13 12:01:55 UTC (rev 54529)
@@ -115,7 +115,7 @@
      union
      {
         const char *strv;
-        unsigned char boolv;
+        Eina_Bool boolv : 1;
         short shortv;
         int intv;
         long longv;
@@ -128,7 +128,7 @@
 
   struct _Ecore_Getopt_Desc_Callback
   {
-     unsigned char (*func)(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+     Eina_Bool (*func)(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
      const void *data;
      Ecore_Getopt_Desc_Arg_Requirement arg_req;
      const char *def;
@@ -387,14 +387,14 @@
 
   EAPI void ecore_getopt_help(FILE *fp, const Ecore_Getopt *info);
 
-  EAPI unsigned char ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
+  EAPI Eina_Bool ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
   EAPI int ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv);
 
   EAPI Eina_List *ecore_getopt_list_free(Eina_List *list);
 
   /* helper functions to be used with ECORE_GETOPT_CALLBACK_*() */
-  EAPI unsigned char ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
-  EAPI unsigned char ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+  EAPI Eina_Bool ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+  EAPI Eina_Bool ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
 
 
 #ifdef __cplusplus

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-13 09:37:15 UTC (rev 54528)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-13 12:01:55 UTC (rev 54529)
@@ -584,7 +584,7 @@
    fputc('\n', fp);
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_desc_is_sentinel(const Ecore_Getopt_Desc *desc)
 {
    return (desc->shortname == '\0') && (!desc->longname);
@@ -797,8 +797,8 @@
    va_end(ap);
 }
 
-static unsigned char
-_ecore_getopt_parse_bool(const char *str, unsigned char *v)
+static Eina_Bool
+_ecore_getopt_parse_bool(const char *str, Eina_Bool *v)
 {
    if ((strcmp(str, "0") == 0) ||
        (strcasecmp(str, "f") == 0) ||
@@ -807,8 +807,8 @@
        (strcasecmp(str, "off") == 0)
        )
      {
-        *v = 0;
-        return 1;
+        *v = EINA_FALSE;
+        return EINA_TRUE;
      }
    else if ((strcmp(str, "1") == 0) ||
             (strcasecmp(str, "t") == 0) ||
@@ -817,14 +817,14 @@
             (strcasecmp(str, "on") == 0)
             )
      {
-        *v = 1;
-        return 1;
+        *v = EINA_TRUE;
+        return EINA_TRUE;
      }
 
-   return 0;
+   return EINA_FALSE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_long(const char *str, long int *v)
 {
    char *endptr = NULL;
@@ -832,7 +832,7 @@
    return endptr > str;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_double(const char *str, double *v)
 {
    char *endptr = NULL;
@@ -840,18 +840,18 @@
    return endptr > str;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_store(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *value, const char *arg_val)
 {
    const Ecore_Getopt_Desc_Store *store = &desc->action_param.store;
    long int v;
    double d;
-   unsigned char b;
+   Eina_Bool b;
 
    if (!value->ptrp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    switch (store->arg_req)
@@ -869,49 +869,49 @@
      {
       case ECORE_GETOPT_TYPE_STR:
          *value->strp = (char *)arg_val;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_BOOL:
          if (_ecore_getopt_parse_bool(arg_val, &b))
            {
               *value->boolp = b;
-              return 1;
+              return EINA_TRUE;
            }
          else
            {
               _ecore_getopt_desc_print_error
                 (desc, _("unknown boolean value %s.\n"), arg_val);
-              return 0;
+              return EINA_FALSE;
            }
       case ECORE_GETOPT_TYPE_SHORT:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->shortp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_INT:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->intp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_LONG:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->longp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_USHORT:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->ushortp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_UINT:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->uintp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_ULONG:
          if (!_ecore_getopt_parse_long(arg_val, &v))
            goto error;
          *value->ulongp = v;
-         return 1;
+         return EINA_TRUE;
       case ECORE_GETOPT_TYPE_DOUBLE:
          if (!_ecore_getopt_parse_double(arg_val, &d))
            goto error;
@@ -919,12 +919,12 @@
          break;
      }
 
-   return 1;
+   return EINA_TRUE;
 
  error:
    _ecore_getopt_desc_print_error
      (desc, _("invalid number format %s\n"), arg_val);
-   return 0;
+   return EINA_FALSE;
 
  use_optional:
    switch (store->type)
@@ -958,47 +958,47 @@
          break;
      }
 
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_store_const(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (!val->ptrp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    *val->ptrp = (void *)desc->action_param.store_const;
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_store_true(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (!val->boolp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
-   *val->boolp = 1;
-   return 1;
+   *val->boolp = EINA_TRUE;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_store_false(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (!val->boolp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
-   *val->boolp = 0;
-   return 1;
+   *val->boolp = EINA_FALSE;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_choice(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
 {
    const char * const *pchoice;
@@ -1006,7 +1006,7 @@
    if (!val->strp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    pchoice = desc->action_param.choices;
@@ -1014,7 +1014,7 @@
      if (strcmp(*pchoice, arg_val) == 0)
        {
           *val->strp = (char *)*pchoice;
-          return 1;
+          return EINA_TRUE;
        }
 
    _ecore_getopt_desc_print_error
@@ -1029,28 +1029,28 @@
      }
 
    fputs(".\n", stderr);
-   return 0;
+   return EINA_FALSE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_append(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
 {
    void *data;
    long int v;
    double d;
-   unsigned char b;
+   Eina_Bool b;
 
    if (!arg_val)
      {
         _ecore_getopt_desc_print_error
           (desc, _("missing parameter to append.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    if (!val->listp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    switch (desc->action_param.append_type)
@@ -1062,15 +1062,14 @@
         {
            if (_ecore_getopt_parse_bool(arg_val, &b))
              {
-                data = malloc(sizeof(unsigned char));
+                data = malloc(sizeof(Eina_Bool));
                 if (data)
-                  *(unsigned char *)data = b;
+                  *(Eina_Bool *)data = b;
              }
            else
              {
-                _ecore_getopt_desc_print_error
-                  (desc, _("unknown boolean value %s.\n"), arg_val);
-                return 0;
+                _ecore_getopt_desc_print_error(desc, _("unknown boolean value %s.\n"), arg_val);
+                return EINA_FALSE;
              }
         }
         break;
@@ -1140,33 +1139,33 @@
       default:
         {
            _ecore_getopt_desc_print_error(desc, _("could not parse value.\n"));
-           return 0;
+           return EINA_FALSE;
         }
      }
 
    *val->listp = eina_list_append(*val->listp, data);
-   return 1;
+   return EINA_TRUE;
 
  error:
    _ecore_getopt_desc_print_error
      (desc, _("invalid number format %s\n"), arg_val);
-   return 0;
+   return EINA_FALSE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_count(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (!val->intp)
      {
         _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    (*val->intp)++;
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_callback(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val)
 {
    const Ecore_Getopt_Desc_Callback *cb = &desc->action_param.callback;
@@ -1189,78 +1188,77 @@
         if ((!arg_val) || (arg_val[0] == '\0'))
           {
              _ecore_getopt_desc_print_error(desc, _("missing parameter.\n"));
-             return 0;
+             return EINA_FALSE;
           }
 
         if (!val->ptrp)
           {
-             _ecore_getopt_desc_print_error
-               (desc, _("value has no pointer set.\n"));
-             return 0;
+             _ecore_getopt_desc_print_error(desc, _("value has no pointer set.\n"));
+             return EINA_FALSE;
           }
      }
 
    if (!cb->func)
      {
         _ecore_getopt_desc_print_error(desc, _("missing callback function!\n"));
-        return 0;
+        return EINA_FALSE;
      }
 
    return cb->func(parser, desc, arg_val, (void *)cb->data, val);
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_help(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc __UNUSED__, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (val->boolp)
-     (*val->boolp) = 1;
+     (*val->boolp) = EINA_TRUE;
    ecore_getopt_help(stdout, parser);
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_version(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (val->boolp)
-     (*val->boolp) = 1;
+     (*val->boolp) = EINA_TRUE;
    if (!parser->version)
      {
         _ecore_getopt_desc_print_error(desc, _("no version was defined.\n"));
-        return 0;
+        return EINA_FALSE;
      }
    _ecore_getopt_version(stdout, parser);
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_copyright(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (val->boolp)
-     (*val->boolp) = 1;
+     (*val->boolp) = EINA_TRUE;
    if (!parser->copyright)
      {
         _ecore_getopt_desc_print_error(desc, _("no copyright was defined.\n"));
-        return 0;
+        return EINA_FALSE;
      }
    _ecore_getopt_copyright(stdout, parser);
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_license(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *val, const char *arg_val __UNUSED__)
 {
    if (val->boolp)
-     (*val->boolp) = 1;
+     (*val->boolp) = EINA_TRUE;
    if (!parser->license)
      {
         _ecore_getopt_desc_print_error(desc, _("no license was defined.\n"));
-        return 0;
+        return EINA_FALSE;
      }
    _ecore_getopt_license(stdout, parser);
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_desc_handle(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, Ecore_Getopt_Value *value, const char *arg_val)
 {
    switch (desc->action)
@@ -1290,11 +1288,11 @@
       case ECORE_GETOPT_ACTION_LICENSE:
          return _ecore_getopt_parse_license(parser, desc, value, arg_val);
       default:
-         return 0;
+         return EINA_FALSE;
      }
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_arg_long(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc __UNUSED__, char **argv, int *idx, int *nonargs, const char *arg)
 {
    const Ecore_Getopt_Desc *desc;
@@ -1302,17 +1300,17 @@
    const char *arg_val;
    int desc_idx;
    Ecore_Getopt_Value *value;
-   unsigned char ret;
+   Eina_Bool ret;
 
    desc = _ecore_getopt_parse_find_long(parser, arg);
    if (!desc)
      {
         fprintf(stderr, _("ERROR: unknown option --%s, ignored.\n"), arg);
         if (parser->strict)
-          return 0;
+          return EINA_FALSE;
 
         (*idx)++;
-        return 1;
+        return EINA_TRUE;
      }
 
    (*idx)++;
@@ -1342,8 +1340,8 @@
              fprintf
                (stderr, _("ERROR: option --%s requires an argument!\n"), arg);
              if (parser->strict)
-               return 0;
-             return 1;
+               return EINA_FALSE;
+             return EINA_TRUE;
           }
      }
    else
@@ -1353,12 +1351,12 @@
    value = values + desc_idx;
    ret = _ecore_getopt_desc_handle(parser, desc, value, arg_val);
    if ((!ret) && parser->strict)
-     return 0;
+     return EINA_FALSE;
 
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_arg_short(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc __UNUSED__, char **argv, int *idx, int *nonargs, const char *arg)
 {
    int run = 1;
@@ -1370,7 +1368,7 @@
         const char *arg_val;
         int desc_idx;
         Ecore_Getopt_Value *value;
-        unsigned char ret;
+        Eina_Bool ret;
 
         desc = _ecore_getopt_parse_find_short(parser, arg[0]);
         if (!desc)
@@ -1378,7 +1376,7 @@
              fprintf
                (stderr, _("ERROR: unknown option -%c, ignored.\n"), arg[0]);
              if (parser->strict)
-               return 0;
+               return EINA_FALSE;
 
              arg++;
              continue;
@@ -1417,8 +1415,8 @@
                     (stderr, _("ERROR: option -%c requires an argument!\n"),
                      opt);
                   if (parser->strict)
-                    return 0;
-                  return 1;
+                    return EINA_FALSE;
+                  return EINA_TRUE;
                }
           }
         else
@@ -1428,16 +1426,16 @@
         value = values + desc_idx;
         ret = _ecore_getopt_desc_handle(parser, desc, value, arg_val);
         if ((!ret) && parser->strict)
-          return 0;
+          return EINA_FALSE;
      }
 
    if (run)
      (*idx)++;
 
-   return 1;
+   return EINA_TRUE;
 }
 
-static unsigned char
+static Eina_Bool
 _ecore_getopt_parse_arg(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv, int *idx, int *nonargs)
 {
    char *arg = argv[*idx];
@@ -1455,15 +1453,13 @@
 
         *dst = arg;
         (*nonargs)--;
-        return 1;
+        return EINA_TRUE;
      }
 
    if (arg[1] == '-')
-     return _ecore_getopt_parse_arg_long
-       (parser, values, argc, argv, idx, nonargs, arg + 2);
+     return _ecore_getopt_parse_arg_long(parser, values, argc, argv, idx, nonargs, arg + 2);
    else
-     return _ecore_getopt_parse_arg_short
-       (parser, values, argc, argv, idx, nonargs, arg + 1);
+     return _ecore_getopt_parse_arg_short(parser, values, argc, argv, idx, nonargs, arg + 1);
 }
 
 static const Ecore_Getopt_Desc *
@@ -1505,9 +1501,9 @@
 /**
  * Check parser for duplicate entries, print them out.
  *
- * @return 1 if there are duplicates, 0 otherwise.
+ * @return EINA_TRUE if there are duplicates, EINA_FALSE otherwise.
  */
-unsigned char
+Eina_Bool
 ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser)
 {
    const Ecore_Getopt_Desc *desc = parser->descs;
@@ -1519,14 +1515,13 @@
            other = _ecore_getopt_parse_find_short_other(parser, desc);
            if (other)
              {
-                _ecore_getopt_desc_print_error
-                  (desc, "short name -%c already exists.", desc->shortname);
+                _ecore_getopt_desc_print_error(desc, "short name -%c already exists.", desc->shortname);
 
                 if (other->longname)
                   fprintf(stderr, " Other is --%s.\n", other->longname);
                 else
                   fputc('\n', stderr);
-                return 1;
+                return EINA_TRUE;
              }
          }
 
@@ -1536,18 +1531,17 @@
            other = _ecore_getopt_parse_find_long_other(parser, desc);
            if (other)
              {
-                _ecore_getopt_desc_print_error
-                  (desc, "long name --%s already exists.", desc->longname);
+                _ecore_getopt_desc_print_error(desc, "long name --%s already exists.", desc->longname);
 
                 if (other->shortname)
                   fprintf(stderr, " Other is -%c.\n", other->shortname);
                 else
                   fputc('\n', stderr);
-                return 1;
+                return EINA_TRUE;
              }
          }
      }
-   return 0;
+   return EINA_FALSE;
 }
 
 static const Ecore_Getopt_Desc *
@@ -1695,7 +1689,7 @@
  *
  * @c callback_data value is ignored, you can safely use @c NULL.
  */
-unsigned char
+Eina_Bool
 ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc __UNUSED__, const char *str, void *data __UNUSED__, Ecore_Getopt_Value *storage)
 {
    Eina_Rectangle *v = (Eina_Rectangle *)storage->ptrp;
@@ -1703,10 +1697,10 @@
    if (sscanf(str, "%d:%d:%d:%d", &v->x, &v->y, &v->w, &v->h) != 4)
      {
         fprintf(stderr, _("ERROR: incorrect geometry value '%s'\n"), str);
-        return 0;
+        return EINA_FALSE;
      }
 
-   return 1;
+   return EINA_TRUE;
 }
 
 /**
@@ -1718,7 +1712,7 @@
  *
  * @c callback_data value is ignored, you can safely use @c NULL.
  */
-unsigned char
+Eina_Bool
 ecore_getopt_callback_size_parse(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc __UNUSED__, const char *str, void *data __UNUSED__, Ecore_Getopt_Value *storage)
 {
    Eina_Rectangle *v = (Eina_Rectangle *)storage->ptrp;
@@ -1726,10 +1720,10 @@
    if (sscanf(str, "%dx%d", &v->w, &v->h) != 2)
      {
         fprintf(stderr, _("ERROR: incorrect size value '%s'\n"), str);
-        return 0;
+        return EINA_FALSE;
      }
    v->x = 0;
    v->y = 0;
 
-   return 1;
+   return EINA_TRUE;
 }

Log:
  revert bitfielding of a bool to avoid possible abi break
  
Author:       discomfitor
Date:         2010-11-13 04:25:45 -0800 (Sat, 13 Nov 2010)
New Revision: 54530

Modified:
  trunk/ecore/src/lib/ecore/Ecore_Getopt.h 

Modified: trunk/ecore/src/lib/ecore/Ecore_Getopt.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-13 12:01:55 UTC (rev 54529)
+++ trunk/ecore/src/lib/ecore/Ecore_Getopt.h	2010-11-13 12:25:45 UTC (rev 54530)
@@ -115,7 +115,7 @@
      union
      {
         const char *strv;
-        Eina_Bool boolv : 1;
+        Eina_Bool boolv;
         short shortv;
         int intv;
         long longv;

Log:
  add doxy for ecore_main_fd_handler_prepare_callback_set, add massive optimization for fd handler scaling (only noticeable with 10000+ fd handlers) to only attempt running prep functions for handlers which have them
  
Author:       discomfitor
Date:         2010-11-16 22:24:49 -0800 (Tue, 16 Nov 2010)
New Revision: 54617

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-16 21:50:53 UTC (rev 54616)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-17 06:24:49 UTC (rev 54617)
@@ -116,6 +116,7 @@
 static Ecore_Fd_Handler *fd_handlers = NULL;
 static Ecore_Fd_Handler *fd_handler_current = NULL;
 static int               fd_handlers_delete_me = 0;
+static Eina_List        *fd_handlers_with_prep = NULL;
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
 static Ecore_Win32_Handler *win32_handler_current = NULL;
@@ -803,6 +804,8 @@
    fd_handler->delete_me = 1;
    fd_handlers_delete_me = 1;
    _ecore_main_fdh_poll_del(fd_handler);
+   if (fd_handler->prep_func)
+     fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
    return fd_handler->data;
 }
 
@@ -828,6 +831,13 @@
 }
 #endif
 
+/**
+ * @brief Set the prepare callback with data for a given #Ecore_Fd_Handler
+ * @param fd_handler The fd handler
+ * @param func The prep function
+ * @param data The data to pass to the prep function
+ * This function will be called prior to the the fd handler's callback function.
+ */
 EAPI void
 ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Prep_Cb func, const void *data)
 {
@@ -839,6 +849,9 @@
      }
    fd_handler->prep_func = func;
    fd_handler->prep_data = (void *)data;
+   if (fd_handlers_with_prep)
+     fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
+   fd_handlers_with_prep = eina_list_append(fd_handlers_with_prep, fd_handler);
 }
 
 /**
@@ -935,6 +948,8 @@
         ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
         free(fdh);
      }
+   eina_list_free(fd_handlers_with_prep);
+   fd_handlers_with_prep = NULL;
    fd_handlers_delete_me = 0;
    fd_handler_current = NULL;
 
@@ -958,16 +973,19 @@
 _ecore_main_prepare_handlers(void)
 {
    Ecore_Fd_Handler *fdh;
+   Eina_List *l, *l2;
 
-   /* call the prepare callback for all handlers */
-   EINA_INLIST_FOREACH(fd_handlers, fdh)
+   /* call the prepare callback for all handlers with prep functions */
+   EINA_LIST_FOREACH_SAFE(fd_handlers_with_prep, l, l2, fdh)
      {
         if (!fdh->delete_me && fdh->prep_func)
           {
              fdh->references++;
-             fdh->prep_func (fdh->prep_data, fdh);
+             fdh->prep_func(fdh->prep_data, fdh);
              fdh->references--;
           }
+        else
+          fd_handlers_with_prep = eina_list_remove_list(fd_handlers_with_prep, l);
      }
 }
 
@@ -1008,7 +1026,8 @@
    FD_ZERO(&exfds);
 
    /* call the prepare callback for all handlers */
-   _ecore_main_prepare_handlers();
+   if (fd_handlers_with_prep)
+     _ecore_main_prepare_handlers();
 #ifndef HAVE_EPOLL
    Ecore_Fd_Handler *fdh;

Log:
  scaling optimizations round 2: add list for fd handler buffer functions
  also delete fdhs from prep/buf lists on cleanups when possible
  
Author:       discomfitor
Date:         2010-11-16 22:50:52 -0800 (Tue, 16 Nov 2010)
New Revision: 54619

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-17 06:41:41 UTC (rev 54618)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-17 06:50:52 UTC (rev 54619)
@@ -117,6 +117,7 @@
 static Ecore_Fd_Handler *fd_handler_current = NULL;
 static int               fd_handlers_delete_me = 0;
 static Eina_List        *fd_handlers_with_prep = NULL;
+static Eina_List        *fd_handlers_with_buffer = NULL;
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
 static Ecore_Win32_Handler *win32_handler_current = NULL;
@@ -400,7 +401,8 @@
         else
           *next_time = 0;
 
-        _ecore_main_prepare_handlers();
+        if (fd_handlers_with_prep)
+          _ecore_main_prepare_handlers();
      }
 
    in_main_loop--;
@@ -479,7 +481,8 @@
      {
         INF("work");
         _ecore_main_fd_handlers_call();
-        _ecore_main_fd_handlers_buf_call();
+        if (fd_handlers_with_buffer)
+          _ecore_main_fd_handlers_buf_call();
         while (_ecore_signal_count_get()) _ecore_signal_call();
         _ecore_event_call();
         _ecore_main_fd_handlers_cleanup();
@@ -744,6 +747,8 @@
    fdh->func = func;
    fdh->data = (void *)data;
    fdh->buf_func = buf_func;
+   if (buf_func)
+     fd_handlers_with_buffer = eina_list_append(fd_handlers_with_buffer, fdh);
    fdh->buf_data = (void *)buf_data;
    fd_handlers = (Ecore_Fd_Handler *)
       eina_inlist_append(EINA_INLIST_GET(fd_handlers),
@@ -806,6 +811,8 @@
    _ecore_main_fdh_poll_del(fd_handler);
    if (fd_handler->prep_func)
      fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
+   if (fd_handler->buf_func)
+     fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fd_handler);
    return fd_handler->data;
 }
 
@@ -948,7 +955,11 @@
         ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
         free(fdh);
      }
-   eina_list_free(fd_handlers_with_prep);
+   if (fd_handlers_with_buffer)
+     eina_list_free(fd_handlers_with_buffer);
+   fd_handlers_with_buffer = NULL;
+   if (fd_handlers_with_prep)
+     eina_list_free(fd_handlers_with_prep);
    fd_handlers_with_prep = NULL;
    fd_handlers_delete_me = 0;
    fd_handler_current = NULL;
@@ -1171,7 +1182,10 @@
                   deleted_in_use++;
                   continue;
                }
-             
+             if (fdh->buf_func)
+               fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fdh);
+             if (fdh->prep_func)
+               fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
              fd_handlers = (Ecore_Fd_Handler *)
                 eina_inlist_remove(EINA_INLIST_GET(fd_handlers),
                                    EINA_INLIST_GET(fdh));
@@ -1262,24 +1276,24 @@
 _ecore_main_fd_handlers_buf_call(void)
 {
    Ecore_Fd_Handler *fdh;
+   Eina_List *l, *l2;
    int ret;
 
    ret = 0;
-   EINA_INLIST_FOREACH(fd_handlers, fdh)
+   EINA_LIST_FOREACH_SAFE(fd_handlers_with_buffer, l, l2, fdh)
      {
-        if (!fdh->delete_me)
+        if ((!fdh->delete_me) && fdh->buf_func)
           {
-             if (fdh->buf_func)
+             fdh->references++;
+             if (fdh->buf_func(fdh->buf_data, fdh))
                {
-                  fdh->references++;
-                  if (fdh->buf_func(fdh->buf_data, fdh))
-                    {
-                       ret |= fdh->func(fdh->data, fdh);
-                       fdh->read_active = 1;
-                    }
-                  fdh->references--;
+                  ret |= fdh->func(fdh->data, fdh);
+                  fdh->read_active = 1;
                }
+             fdh->references--;
           }
+        else
+          fd_handlers_with_buffer = eina_list_remove_list(fd_handlers_with_buffer, l);
      }
    return ret;
 }
@@ -1325,7 +1339,8 @@
      }
 
    /* if these calls caused any buffered events to appear - deal with them */
-   _ecore_main_fd_handlers_buf_call();
+   if (fd_handlers_with_buffer)
+     _ecore_main_fd_handlers_buf_call();
 
    /* if there are any - jump to processing them */
    if (_ecore_event_exist())
@@ -1423,7 +1438,8 @@
    /* post events onto the ecore event pipe if necessary */
    process_events:
    _ecore_main_fd_handlers_call();
-   _ecore_main_fd_handlers_buf_call();
+   if (fd_handlers_with_buffer)
+     _ecore_main_fd_handlers_buf_call();
    /* process signals into events .... */
    while (_ecore_signal_count_get()) _ecore_signal_call();
    /* handle events ... */

Log:
  fix list removal for prep/buf functions to avoid annoying eina warnings
  
Author:       discomfitor
Date:         2010-11-16 22:57:29 -0800 (Tue, 16 Nov 2010)
New Revision: 54620

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-17 06:50:52 UTC (rev 54619)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-17 06:57:29 UTC (rev 54620)
@@ -809,9 +809,9 @@
    fd_handler->delete_me = 1;
    fd_handlers_delete_me = 1;
    _ecore_main_fdh_poll_del(fd_handler);
-   if (fd_handler->prep_func)
+   if (fd_handler->prep_func && fd_handlers_with_prep)
      fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
-   if (fd_handler->buf_func)
+   if (fd_handler->buf_func && fd_handlers_with_buffer)
      fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fd_handler);
    return fd_handler->data;
 }
@@ -856,9 +856,9 @@
      }
    fd_handler->prep_func = func;
    fd_handler->prep_data = (void *)data;
-   if (fd_handlers_with_prep)
-     fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
-   fd_handlers_with_prep = eina_list_append(fd_handlers_with_prep, fd_handler);
+   if (fd_handlers_with_prep && (!eina_list_data_find(fd_handlers_with_prep, fd_handler)))
+     /* FIXME: THIS WILL NOT SCALE WITH LOTS OF PREP FUNCTIONS!!! */
+     fd_handlers_with_prep = eina_list_append(fd_handlers_with_prep, fd_handler);
 }
 
 /**
@@ -1182,9 +1182,9 @@
                   deleted_in_use++;
                   continue;
                }
-             if (fdh->buf_func)
+             if (fdh->buf_func && fd_handlers_with_buffer)
                fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fdh);
-             if (fdh->prep_func)
+             if (fdh->prep_func && fd_handlers_with_prep)
                fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
              fd_handlers = (Ecore_Fd_Handler *)
                 eina_inlist_remove(EINA_INLIST_GET(fd_handlers),

Log:
  remove the last (I think?) O(n) operation from ecore fd handling
  
Author:       discomfitor
Date:         2010-11-17 23:23:14 -0800 (Wed, 17 Nov 2010)
New Revision: 54669

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-18 05:53:38 UTC (rev 54668)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-18 07:23:14 UTC (rev 54669)
@@ -115,9 +115,10 @@
 static int               do_quit = 0;
 static Ecore_Fd_Handler *fd_handlers = NULL;
 static Ecore_Fd_Handler *fd_handler_current = NULL;
-static int               fd_handlers_delete_me = 0;
 static Eina_List        *fd_handlers_with_prep = NULL;
 static Eina_List        *fd_handlers_with_buffer = NULL;
+static Eina_List        *fd_handlers_to_delete = NULL;
+
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
 static Ecore_Win32_Handler *win32_handler_current = NULL;
@@ -807,8 +808,8 @@
         return NULL;
      }
    fd_handler->delete_me = 1;
-   fd_handlers_delete_me = 1;
    _ecore_main_fdh_poll_del(fd_handler);
+   fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fd_handler);
    if (fd_handler->prep_func && fd_handlers_with_prep)
      fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fd_handler);
    if (fd_handler->buf_func && fd_handlers_with_buffer)
@@ -961,7 +962,9 @@
    if (fd_handlers_with_prep)
      eina_list_free(fd_handlers_with_prep);
    fd_handlers_with_prep = NULL;
-   fd_handlers_delete_me = 0;
+   if (fd_handlers_to_delete)
+     eina_list_free(fd_handlers_to_delete);
+   fd_handlers_to_delete = NULL;
    fd_handler_current = NULL;
 
 #ifdef _WIN32
@@ -1136,7 +1139,7 @@
                     {
                        ERR("Fd function err returned 0, remove it");
                        fdh->delete_me = 1;
-                       fd_handlers_delete_me = 1;
+                       fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                        found++;
                     }
                   fdh->references--;
@@ -1145,7 +1148,7 @@
                {
                   ERR("Problematic fd found at %d! setting it for delete", fdh->fd);
                   fdh->delete_me = 1;
-                  fd_handlers_delete_me = 1;
+                  fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                   found++;
                }
           }
@@ -1166,34 +1169,24 @@
 _ecore_main_fd_handlers_cleanup(void)
 {
    Ecore_Fd_Handler *fdh;
-   Eina_Inlist *l;
-   int deleted_in_use = 0;
+   Eina_List *l, *l2;
 
-   if (!fd_handlers_delete_me) return;
-   for (l = EINA_INLIST_GET(fd_handlers); l; )
+   if (!fd_handlers_to_delete) return;
+   EINA_LIST_FOREACH_SAFE(fd_handlers_to_delete, l, l2, fdh)
      {
-        fdh = (Ecore_Fd_Handler *) l;
-
-        l = l->next;
-        if (fdh->delete_me)
-          {
-             if (fdh->references)
-               {
-                  deleted_in_use++;
-                  continue;
-               }
-             if (fdh->buf_func && fd_handlers_with_buffer)
-               fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fdh);
-             if (fdh->prep_func && fd_handlers_with_prep)
-               fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
-             fd_handlers = (Ecore_Fd_Handler *)
-                eina_inlist_remove(EINA_INLIST_GET(fd_handlers),
-                                   EINA_INLIST_GET(fdh));
-             ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
-             free(fdh);
-          }
+        /* fdh->delete_me should be set for all fdhs at the start of the list */
+        if (fdh->references)
+          continue;
+        if (fdh->buf_func && fd_handlers_with_buffer)
+          fd_handlers_with_buffer = eina_list_remove(fd_handlers_with_buffer, fdh);
+        if (fdh->prep_func && fd_handlers_with_prep)
+          fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
+        fd_handlers = (Ecore_Fd_Handler *)
+                      eina_inlist_remove(EINA_INLIST_GET(fd_handlers), EINA_INLIST_GET(fdh));
+        ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
+        free(fdh);
+        fd_handlers_to_delete = eina_list_remove_list(fd_handlers_to_delete, l);
      }
-   if (!deleted_in_use) fd_handlers_delete_me = 0;
 }
 
 #ifdef _WIN32
@@ -1257,7 +1250,7 @@
                   if (!fdh->func(fdh->data, fdh))
                     {
                        fdh->delete_me = 1;
-                       fd_handlers_delete_me = 1;
+                       fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                     }
                   fdh->references--;

Log:
  to fix the bug that morlenxus found, I have crashed my own computer.
  this commit fixes a rare case where a fdh can be in the delete list twice, causing a double free
  
Author:       discomfitor
Date:         2010-11-18 11:56:26 -0800 (Thu, 18 Nov 2010)
New Revision: 54702

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-18 19:13:54 UTC (rev 54701)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-18 19:56:26 UTC (rev 54702)
@@ -807,6 +807,10 @@
                          "ecore_main_fd_handler_del");
         return NULL;
      }
+   if (fd_handler->delete_me)
+     /* FIXME: should this return NULL instead? */
+     return fd_handler->data;
+     
    fd_handler->delete_me = 1;
    _ecore_main_fdh_poll_del(fd_handler);
    fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fd_handler);
@@ -1138,8 +1142,11 @@
                   if (!fdh->func(fdh->data, fdh))
                     {
                        ERR("Fd function err returned 0, remove it");
-                       fdh->delete_me = 1;
-                       fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                       if (!fdh->delete_me)
+                         {
+                            fdh->delete_me = 1;
+                            fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                         }
                        found++;
                     }
                   fdh->references--;
@@ -1147,8 +1154,12 @@
              else
                {
                   ERR("Problematic fd found at %d! setting it for delete", fdh->fd);
-                  fdh->delete_me = 1;
-                  fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                  if (!fdh->delete_me)
+                    {
+                       fdh->delete_me = 1;
+                       fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                    }
+
                   found++;
                }
           }
@@ -1249,8 +1260,12 @@
                   fdh->references++;
                   if (!fdh->func(fdh->data, fdh))
                     {
-                       fdh->delete_me = 1;
-                       fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                       if (!fdh->delete_me)
+                         {
+                            fdh->delete_me = 1;
+                            fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
+                         }
+
                     }
                   fdh->references--;

Log:
  fix bug where getopt_parse returns 1 when there are no args
  
Author:       discomfitor
Date:         2010-11-23 02:25:58 -0800 (Tue, 23 Nov 2010)
New Revision: 54860

Modified:
  trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:04:44 UTC (rev 54859)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:25:58 UTC (rev 54860)
@@ -1602,7 +1602,7 @@
  *        retrieved with ecore_app_args_get().
  * @param argv command line parameters.
  *
- * @return index of first non-option parameter or -1 on error.
+ * @return index of first non-option parameter, 0 if only a progname is passed, or -1 on error.
  */
 int
 ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv)
@@ -1634,6 +1634,7 @@
    else
      prog = parser->prog;
 
+   if (argc == 1) return 0;
    nonargs = _ecore_getopt_parse_find_nonargs_base(parser, argc, argv);
    if (nonargs < 0)
      goto error;

Log:
  fix bug where getopt_parse returns argc as the first nonopt argument when there are no nonopt arguments
  
Author:       discomfitor
Date:         2010-11-23 02:36:15 -0800 (Tue, 23 Nov 2010)
New Revision: 54861

Modified:
  trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:25:58 UTC (rev 54860)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:36:15 UTC (rev 54861)
@@ -764,7 +764,11 @@
         dst++;
      }
 
-   memmove(argv + dst, nonargs, used * sizeof(char *));
+   if (base != argc)
+     memmove(argv + dst, nonargs, used * sizeof(char *));
+   else
+     /* return 0 since argv[0] is technically the nonargs base */
+     base = 0;
    return base;
 }

Log:
  more correctly fix no-option parsing to still parse when no non-arg options are found
  
Author:       discomfitor
Date:         2010-11-23 02:56:50 -0800 (Tue, 23 Nov 2010)
New Revision: 54862

Modified:
  trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:36:15 UTC (rev 54861)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:56:50 UTC (rev 54862)
@@ -1638,7 +1638,6 @@
    else
      prog = parser->prog;
 
-   if (argc == 1) return 0;
    nonargs = _ecore_getopt_parse_find_nonargs_base(parser, argc, argv);
    if (nonargs < 0)
      goto error;
@@ -1647,7 +1646,7 @@
      nonargs = argc;
 
    i = 1;
-   while (i < nonargs)
+   while ((i < nonargs ? nonargs : argc) && (argv[i]))
      if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &nonargs))
        goto error;

Log:
  I'm tired of you, ecore_getopt. now you get the hammer.
  
Author:       discomfitor
Date:         2010-11-23 03:10:41 -0800 (Tue, 23 Nov 2010)
New Revision: 54863

Modified:
  trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 10:56:50 UTC (rev 54862)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 11:10:41 UTC (rev 54863)
@@ -1646,10 +1646,21 @@
      nonargs = argc;
 
    i = 1;
-   while ((i < nonargs ? nonargs : argc) && (argv[i]))
-     if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &nonargs))
-       goto error;
+   if (nonargs)
+     {
+        while (i < nonargs)
+          if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &nonargs))
+            goto error;
+     }
+   else
+     {
+        int tmp = 0;
 
+        while (i < argc)
+          if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &tmp))
+            goto error;
+     }
+
    return nonargs;
 
  error:

Log:
  revert this for crankypants
  
Author:       discomfitor
Date:         2010-11-23 06:46:12 -0800 (Tue, 23 Nov 2010)
New Revision: 54888

Modified:
  trunk/ecore/src/lib/ecore/ecore_getopt.c 

Modified: trunk/ecore/src/lib/ecore/ecore_getopt.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 13:30:51 UTC (rev 54887)
+++ trunk/ecore/src/lib/ecore/ecore_getopt.c	2010-11-23 14:46:12 UTC (rev 54888)
@@ -764,11 +764,7 @@
         dst++;
      }
 
-   if (base != argc)
-     memmove(argv + dst, nonargs, used * sizeof(char *));
-   else
-     /* return 0 since argv[0] is technically the nonargs base */
-     base = 0;
+   memmove(argv + dst, nonargs, used * sizeof(char *));
    return base;
 }
 
@@ -1606,7 +1602,7 @@
  *        retrieved with ecore_app_args_get().
  * @param argv command line parameters.
  *
- * @return index of first non-option parameter, 0 if only a progname is passed, or -1 on error.
+ * @return index of first non-option parameter or -1 on error.
  */
 int
 ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv)
@@ -1646,21 +1642,10 @@
      nonargs = argc;
 
    i = 1;
-   if (nonargs)
-     {
-        while (i < nonargs)
-          if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &nonargs))
-            goto error;
-     }
-   else
-     {
-        int tmp = 0;
+   while (i < nonargs)
+     if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &nonargs))
+       goto error;
 
-        while (i < argc)
-          if (!_ecore_getopt_parse_arg(parser, values, argc, argv, &i, &tmp))
-            goto error;
-     }
-
    return nonargs;
 
  error:

Log:
  fix weird bug where fdh in a list could become null
  
Author:       discomfitor
Date:         2010-11-28 14:03:07 -0800 (Sun, 28 Nov 2010)
New Revision: 55044

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-28 21:51:07 UTC (rev 55043)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-11-28 22:03:07 UTC (rev 55044)
@@ -996,6 +996,7 @@
    /* call the prepare callback for all handlers with prep functions */
    EINA_LIST_FOREACH_SAFE(fd_handlers_with_prep, l, l2, fdh)
      {
+        if (!fdh) fd_handlers_with_prep = eina_list_remove_list(l, fd_handlers_with_prep);
         if (!fdh->delete_me && fdh->prep_func)
           {
              fdh->references++;
@@ -1185,6 +1186,7 @@
    if (!fd_handlers_to_delete) return;
    EINA_LIST_FOREACH_SAFE(fd_handlers_to_delete, l, l2, fdh)
      {
+        if (!fdh) fd_handlers_to_delete = eina_list_remove_list(l, fd_handlers_to_delete);
         /* fdh->delete_me should be set for all fdhs at the start of the list */
         if (fdh->references)
           continue;
@@ -1290,6 +1292,7 @@
    ret = 0;
    EINA_LIST_FOREACH_SAFE(fd_handlers_with_buffer, l, l2, fdh)
      {
+        if (!fdh) fd_handlers_with_buffer = eina_list_remove_list(l, fd_handlers_with_buffer);
         if ((!fdh->delete_me) && fdh->buf_func)
           {
              fdh->references++;

Log:
use EINA_(TRUE/FALSE) instead of 1/0
  

Author:       discomfitor
Date:         2010-11-30 17:17:45 -0800 (Tue, 30 Nov 2010)
New Revision: 55101
Trac:         http://trac.enlightenment.org/e/changeset/55101

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 00:59:37 UTC (rev 55100)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 01:17:45 UTC (rev 55101)
@@ -329,9 +329,9 @@
              ERR("deleted fd in epoll");
              continue;
           }
-        if (ev[i].events & EPOLLIN) fdh->read_active = 1;
-        if (ev[i].events & EPOLLOUT) fdh->write_active = 1;
-        if (ev[i].events & EPOLLERR) fdh->error_active = 1;
+        if (ev[i].events & EPOLLIN) fdh->read_active = EINA_TRUE;
+        if (ev[i].events & EPOLLOUT) fdh->write_active = EINA_TRUE;
+        if (ev[i].events & EPOLLERR) fdh->error_active = EINA_TRUE;
      }
 
    return ret;
@@ -350,9 +350,9 @@
         if (fdh->delete_me)
            continue;
         
-        if (fdh->gfd.revents & G_IO_IN) fdh->read_active = 1;
-        if (fdh->gfd.revents & G_IO_OUT) fdh->write_active = 1;
-        if (fdh->gfd.revents & G_IO_ERR) fdh->error_active = 1;
+        if (fdh->gfd.revents & G_IO_IN) fdh->read_active = EINA_TRUE;
+        if (fdh->gfd.revents & G_IO_OUT) fdh->write_active = EINA_TRUE;
+        if (fdh->gfd.revents & G_IO_ERR) fdh->error_active = EINA_TRUE;
         if (fdh->gfd.revents & (G_IO_IN|G_IO_OUT|G_IO_ERR)) ret++;
      }
 
@@ -741,9 +741,9 @@
         free(fdh);
         return NULL;
      }
-   fdh->read_active = 0;
-   fdh->write_active = 0;
-   fdh->error_active = 0;
+   fdh->read_active = EINA_FALSE;
+   fdh->write_active = EINA_FALSE;
+   fdh->error_active = EINA_FALSE;
    fdh->delete_me = 0;
    fdh->func = func;
    fdh->data = (void *)data;
@@ -1101,11 +1101,11 @@
              if (!fdh->delete_me)
                {
                   if (FD_ISSET(fdh->fd, &rfds))
-                     fdh->read_active = 1;
+                     fdh->read_active = EINA_TRUE;
                   if (FD_ISSET(fdh->fd, &wfds))
-                     fdh->write_active = 1;
+                     fdh->write_active = EINA_TRUE;
                   if (FD_ISSET(fdh->fd, &exfds))
-                     fdh->error_active = 1;
+                     fdh->error_active = EINA_TRUE;
                }
           }
 #endif /* HAVE_EPOLL */
@@ -1271,9 +1271,9 @@
                     }
                   fdh->references--;
 
-                  fdh->read_active = 0;
-                  fdh->write_active = 0;
-                  fdh->error_active = 0;
+                  fdh->read_active = EINA_FALSE;
+                  fdh->write_active = EINA_FALSE;
+                  fdh->error_active = EINA_FALSE;
                }
           }
 
@@ -1299,7 +1299,7 @@
              if (fdh->buf_func(fdh->buf_data, fdh))
                {
                   ret |= fdh->func(fdh->data, fdh);
-                  fdh->read_active = 1;
+                  fdh->read_active = EINA_TRUE;
                }
              fdh->references--;
           }

Log:
switch to EINA_BOOL values for delete_me, fix huge O(n) behavior in _ecore_main_fd_handlers_call; all fd operations now should see an exponential speed increase based on the number of fds that ecore is watching
  

Author:       discomfitor
Date:         2010-11-30 18:34:48 -0800 (Tue, 30 Nov 2010)
New Revision: 55102
Trac:         http://trac.enlightenment.org/e/changeset/55102

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 01:17:45 UTC (rev 55101)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 02:34:48 UTC (rev 55102)
@@ -119,10 +119,14 @@
 static Eina_List        *fd_handlers_with_buffer = NULL;
 static Eina_List        *fd_handlers_to_delete = NULL;
 
+static Eina_List        *fd_handlers_to_call = NULL;
+static Eina_List        *fd_handlers_to_call_current;
+static Eina_List        *fd_handlers_to_call_current_next;
+
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
 static Ecore_Win32_Handler *win32_handler_current = NULL;
-static int                  win32_handlers_delete_me = 0;
+static int                  win32_handlers_delete_me = EINA_FALSE;
 #endif
 
 #ifdef _WIN32
@@ -329,9 +333,33 @@
              ERR("deleted fd in epoll");
              continue;
           }
-        if (ev[i].events & EPOLLIN) fdh->read_active = EINA_TRUE;
-        if (ev[i].events & EPOLLOUT) fdh->write_active = EINA_TRUE;
-        if (ev[i].events & EPOLLERR) fdh->error_active = EINA_TRUE;
+        if (ev[i].events & EPOLLIN)
+          {
+             if (!fdh->read_active)
+               {
+                  fdh->read_active = EINA_TRUE;
+                  if ((!fdh->write_active) && (!fdh->error_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
+        if (ev[i].events & EPOLLOUT)
+          {
+             if (!fdh->write_active)
+               {
+                  fdh->write_active = EINA_TRUE;
+                  if ((!fdh->read_active) && (!fdh->error_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
+        if (ev[i].events & EPOLLERR)
+          {
+             if (!fdh->error_active)
+               {
+                  fdh->error_active = EINA_TRUE;
+                  if ((!fdh->read_active) && (!fdh->write_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
      }
 
    return ret;
@@ -350,9 +378,33 @@
         if (fdh->delete_me)
            continue;
         
-        if (fdh->gfd.revents & G_IO_IN) fdh->read_active = EINA_TRUE;
-        if (fdh->gfd.revents & G_IO_OUT) fdh->write_active = EINA_TRUE;
-        if (fdh->gfd.revents & G_IO_ERR) fdh->error_active = EINA_TRUE;
+        if (fdh->gfd.revents & G_IO_IN)
+          {
+             if (!fdh->read_active)
+               {
+                  fdh->read_active = EINA_TRUE;
+                  if ((!fdh->write_active) && (!fdh->error_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
+        if (fdh->gfd.revents & G_IO_OUT)
+          {
+             if (!fdh->write_active)
+               {
+                  fdh->write_active = EINA_TRUE;
+                  if ((!fdh->read_active) && (!fdh->error_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
+        if (fdh->gfd.revents & G_IO_ERR)
+          {
+             if (!fdh->error_active)
+               {
+                  fdh->error_active = EINA_TRUE;
+                  if ((!fdh->read_active) && (!fdh->write_active))
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+               }
+          }
         if (fdh->gfd.revents & (G_IO_IN|G_IO_OUT|G_IO_ERR)) ret++;
      }
 
@@ -744,7 +796,7 @@
    fdh->read_active = EINA_FALSE;
    fdh->write_active = EINA_FALSE;
    fdh->error_active = EINA_FALSE;
-   fdh->delete_me = 0;
+   fdh->delete_me = EINA_FALSE;
    fdh->func = func;
    fdh->data = (void *)data;
    fdh->buf_func = buf_func;
@@ -769,7 +821,7 @@
    if (!wh) return NULL;
    ECORE_MAGIC_SET(wh, ECORE_MAGIC_WIN32_HANDLER);
    wh->h = (HANDLE)h;
-   wh->delete_me = 0;
+   wh->delete_me = EINA_FALSE;
    wh->func = func;
    wh->data = (void *)data;
    win32_handlers = (Ecore_Win32_Handler *)
@@ -811,7 +863,7 @@
      /* FIXME: should this return NULL instead? */
      return fd_handler->data;
      
-   fd_handler->delete_me = 1;
+   fd_handler->delete_me = EINA_TRUE;
    _ecore_main_fdh_poll_del(fd_handler);
    fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fd_handler);
    if (fd_handler->prep_func && fd_handlers_with_prep)
@@ -831,8 +883,8 @@
                          "ecore_main_win32_handler_del");
         return NULL;
      }
-   win32_handler->delete_me = 1;
-   win32_handlers_delete_me = 1;
+   win32_handler->delete_me = EINA_TRUE;
+   win32_handlers_delete_me = EINA_TRUE;
    return win32_handler->data;
 }
 #else
@@ -968,6 +1020,10 @@
    fd_handlers_with_prep = NULL;
    if (fd_handlers_to_delete)
      eina_list_free(fd_handlers_to_delete);
+   if (fd_handlers_to_call)
+     eina_list_free(fd_handlers_to_call);
+   fd_handlers_to_call = NULL;
+   fd_handlers_to_call_current = NULL;
    fd_handlers_to_delete = NULL;
    fd_handler_current = NULL;
 
@@ -982,7 +1038,7 @@
         ECORE_MAGIC_SET(wh, ECORE_MAGIC_NONE);
         free(wh);
      }
-   win32_handlers_delete_me = 0;
+   win32_handlers_delete_me = EINA_FALSE;
    win32_handler_current = NULL;
 #endif
 }
@@ -1101,11 +1157,32 @@
              if (!fdh->delete_me)
                {
                   if (FD_ISSET(fdh->fd, &rfds))
-                     fdh->read_active = EINA_TRUE;
+                    {
+                       if (!fdh->read_active)
+                         {
+                            fdh->read_active = EINA_TRUE;
+                            if ((!fdh->write_active) && (!fdh->error_active))
+                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+                         }
+                    }
                   if (FD_ISSET(fdh->fd, &wfds))
-                     fdh->write_active = EINA_TRUE;
+                    {
+                       if (!fdh->write_active)
+                         {
+                            fdh->write_active = EINA_TRUE;
+                            if ((!fdh->read_active) && (!fdh->error_active))
+                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+                         }
+                    }
                   if (FD_ISSET(fdh->fd, &exfds))
-                     fdh->error_active = EINA_TRUE;
+                    {
+                       if (!fdh->error_active)
+                         {
+                            fdh->error_active = EINA_TRUE;
+                            if ((!fdh->read_active) && (!fdh->write_active))
+                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+                         }
+                    }
                }
           }
 #endif /* HAVE_EPOLL */
@@ -1145,7 +1222,7 @@
                        ERR("Fd function err returned 0, remove it");
                        if (!fdh->delete_me)
                          {
-                            fdh->delete_me = 1;
+                            fdh->delete_me = EINA_TRUE;
                             fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                          }
                        found++;
@@ -1157,7 +1234,7 @@
                   ERR("Problematic fd found at %d! setting it for delete", fdh->fd);
                   if (!fdh->delete_me)
                     {
-                       fdh->delete_me = 1;
+                       fdh->delete_me = EINA_TRUE;
                        fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                     }
 
@@ -1231,27 +1308,29 @@
              free(wh);
           }
      }
-   if (!deleted_in_use) win32_handlers_delete_me = 0;
+   if (!deleted_in_use) win32_handlers_delete_me = EINA_FALSE;
 }
 #endif
 
 static void
 _ecore_main_fd_handlers_call(void)
 {
-   if (!fd_handler_current)
+   if (!fd_handlers_to_call_current)
      {
         /* regular main loop, start from head */
-        fd_handler_current = fd_handlers;
+        fd_handlers_to_call_current = fd_handlers_to_call;
+        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current);
      }
    else
      {
         /* recursive main loop, continue from where we were */
-        fd_handler_current = (Ecore_Fd_Handler *)EINA_INLIST_GET(fd_handler_current)->next;
+        fd_handlers_to_call_current = fd_handlers_to_call_current_next;
+        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current);
      }
 
-   while (fd_handler_current)
+   while (fd_handlers_to_call_current)
      {
-        Ecore_Fd_Handler *fdh = fd_handler_current;
+        Ecore_Fd_Handler *fdh = fd_handlers_to_call_current->data;
 
         if (!fdh->delete_me)
           {
@@ -1264,7 +1343,7 @@
                     {
                        if (!fdh->delete_me)
                          {
-                            fdh->delete_me = 1;
+                            fdh->delete_me = EINA_TRUE;
                             fd_handlers_to_delete = eina_list_append(fd_handlers_to_delete, fdh);
                          }
 
@@ -1277,8 +1356,9 @@
                }
           }
 
-        if (fd_handler_current) /* may have changed in recursive main loops */
-          fd_handler_current = (Ecore_Fd_Handler *)EINA_INLIST_GET(fd_handler_current)->next;
+        fd_handlers_to_call = eina_list_remove_list(fd_handlers_to_call, fd_handlers_to_call_current);
+        fd_handlers_to_call_current = fd_handlers_to_call_current_next;
+        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current_next);
      }
 }
 
@@ -1299,7 +1379,15 @@
              if (fdh->buf_func(fdh->buf_data, fdh))
                {
                   ret |= fdh->func(fdh->data, fdh);
-                  fdh->read_active = EINA_TRUE;
+                  if (!fdh->read_active)
+                    {
+                       if (!fdh->read_active)
+                         {
+                            fdh->read_active = EINA_TRUE;
+                            if ((!fdh->write_active) && (!fdh->error_active))
+                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+                         }
+                    }
                }
              fdh->references--;
           }
@@ -1601,8 +1689,8 @@
                        wh->references++;
                        if (!wh->func(wh->data, wh))
                          {
-                            wh->delete_me = 1;
-                            win32_handlers_delete_me = 1;
+                            wh->delete_me = EINA_TRUE;
+                            win32_handlers_delete_me = EINA_TRUE;
                          }
                        wh->references--;
                     }

Log:
type this as EB for correctness because I'm feeling pedantic
  

Author:       discomfitor
Date:         2010-11-30 18:44:20 -0800 (Tue, 30 Nov 2010)
New Revision: 55103
Trac:         http://trac.enlightenment.org/e/changeset/55103

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 02:34:48 UTC (rev 55102)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 02:44:20 UTC (rev 55103)
@@ -126,7 +126,7 @@
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
 static Ecore_Win32_Handler *win32_handler_current = NULL;
-static int                  win32_handlers_delete_me = EINA_FALSE;
+static Eina_Bool            win32_handlers_delete_me = EINA_FALSE;
 #endif
 
 #ifdef _WIN32

Log:
remove redundant check
  

Author:       discomfitor
Date:         2010-11-30 19:02:03 -0800 (Tue, 30 Nov 2010)
New Revision: 55104
Trac:         http://trac.enlightenment.org/e/changeset/55104

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 02:44:20 UTC (rev 55103)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 03:02:03 UTC (rev 55104)
@@ -1381,12 +1381,9 @@
                   ret |= fdh->func(fdh->data, fdh);
                   if (!fdh->read_active)
                     {
-                       if (!fdh->read_active)
-                         {
-                            fdh->read_active = EINA_TRUE;
-                            if ((!fdh->write_active) && (!fdh->error_active))
-                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-                         }
+                       fdh->read_active = EINA_TRUE;
+                       if ((!fdh->write_active) && (!fdh->error_active))
+                         fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
                     }
                }
              fdh->references--;

Log:
copypastecopypaste
  

Author:       discomfitor
Date:         2010-11-30 19:45:22 -0800 (Tue, 30 Nov 2010)
New Revision: 55108
Trac:         http://trac.enlightenment.org/e/changeset/55108

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 03:31:55 UTC (rev 55107)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 03:45:22 UTC (rev 55108)
@@ -353,6 +353,7 @@
 static inline int _ecore_main_fdh_poll_mark_active(void)
 {
    Ecore_Fd_Handler *fdh;
+   Eina_Bool pst, st;
    int ret = 0;
 
    /* call the prepare callback for all handlers */
@@ -360,34 +361,16 @@
      {
         if (fdh->delete_me)
            continue;
-        
-        if (fdh->gfd.revents & G_IO_IN)
-          {
-             if (!fdh->read_active)
-               {
-                  fdh->read_active = EINA_TRUE;
-                  if ((!fdh->write_active) && (!fdh->error_active))
-                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-               }
-          }
-        if (fdh->gfd.revents & G_IO_OUT)
-          {
-             if (!fdh->write_active)
-               {
-                  fdh->write_active = EINA_TRUE;
-                  if ((!fdh->read_active) && (!fdh->error_active))
-                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-               }
-          }
-        if (fdh->gfd.revents & G_IO_ERR)
-          {
-             if (!fdh->error_active)
-               {
-                  fdh->error_active = EINA_TRUE;
-                  if ((!fdh->read_active) && (!fdh->write_active))
-                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-               }
-          }
+
+        pst = st = fdh->read_active | fdh->write_active | fdh->error_active;
+        if ((fdh->gfd.revents & G_IO_IN) && (!fdh->read_active))
+         st = fdh->read_active = EINA_TRUE;
+        if ((fdh->gfd.revents & G_IO_OUT) && (!fdh->write_active))
+         st = fdh->write_active = EINA_TRUE;
+        if ((fdh->gfd.revents & G_IO_ERR) && (!fdh->error_active))
+         st = fdh->error_active = EINA_TRUE;
+        if (pst != st)
+          fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
         if (fdh->gfd.revents & (G_IO_IN|G_IO_OUT|G_IO_ERR)) ret++;
      }
 
@@ -1137,33 +1120,16 @@
           {
              if (!fdh->delete_me)
                {
-                  if (FD_ISSET(fdh->fd, &rfds))
-                    {
-                       if (!fdh->read_active)
-                         {
-                            fdh->read_active = EINA_TRUE;
-                            if ((!fdh->write_active) && (!fdh->error_active))
-                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-                         }
-                    }
-                  if (FD_ISSET(fdh->fd, &wfds))
-                    {
-                       if (!fdh->write_active)
-                         {
-                            fdh->write_active = EINA_TRUE;
-                            if ((!fdh->read_active) && (!fdh->error_active))
-                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-                         }
-                    }
-                  if (FD_ISSET(fdh->fd, &exfds))
-                    {
-                       if (!fdh->error_active)
-                         {
-                            fdh->error_active = EINA_TRUE;
-                            if ((!fdh->read_active) && (!fdh->write_active))
-                              fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-                         }
-                    }
+                  Eina_Bool pst, st;
+                  pst = st = fdh->read_active | fdh->write_active | fdh->error_active;
+                  if ((FD_ISSET(fdh->fd, &rfds)) && (!fdh->read_active))
+                   st = fdh->read_active = EINA_TRUE;
+                  if ((FD_ISSET(fdh->fd, &wfds)) && (!fdh->write_active))
+                   st = fdh->write_active = EINA_TRUE;
+                  if ((FD_ISSET(fdh->fd, &exfds)) && (!fdh->error_active))
+                   st = fdh->error_active = EINA_TRUE;
+                  if (pst != st)
+                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
                }
           }
 #endif /* HAVE_EPOLL */

Log:
avoid segv
  

Author:       discomfitor
Date:         2010-12-01 02:31:20 -0800 (Wed, 01 Dec 2010)
New Revision: 55117
Trac:         http://trac.enlightenment.org/e/changeset/55117

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 09:54:20 UTC (rev 55116)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-01 10:31:20 UTC (rev 55117)
@@ -1016,7 +1016,11 @@
    /* call the prepare callback for all handlers with prep functions */
    EINA_LIST_FOREACH_SAFE(fd_handlers_with_prep, l, l2, fdh)
      {
-        if (!fdh) fd_handlers_with_prep = eina_list_remove_list(l, fd_handlers_with_prep);
+        if (!fdh)
+          {
+             fd_handlers_with_prep = eina_list_remove_list(l, fd_handlers_with_prep);
+             continue;
+          }
         if (!fdh->delete_me && fdh->prep_func)
           {
              fdh->references++;
@@ -1210,7 +1214,11 @@
    if (!fd_handlers_to_delete) return;
    EINA_LIST_FOREACH_SAFE(fd_handlers_to_delete, l, l2, fdh)
      {
-        if (!fdh) fd_handlers_to_delete = eina_list_remove_list(l, fd_handlers_to_delete);
+        if (!fdh)
+          {
+             fd_handlers_to_delete = eina_list_remove_list(l, fd_handlers_to_delete);
+             continue;
+          }
         /* fdh->delete_me should be set for all fdhs at the start of the list */
         if (fdh->references)
           continue;
@@ -1319,7 +1327,11 @@
    ret = 0;
    EINA_LIST_FOREACH_SAFE(fd_handlers_with_buffer, l, l2, fdh)
      {
-        if (!fdh) fd_handlers_with_buffer = eina_list_remove_list(l, fd_handlers_with_buffer);
+        if (!fdh)
+          {
+             fd_handlers_with_buffer = eina_list_remove_list(l, fd_handlers_with_buffer);
+             continue;
+          }
         if ((!fdh->delete_me) && fdh->buf_func)
           {
              fdh->references++;

Log:
From: Mike McCormack <mj.mccormack@...>
  Date: Mon, 20 Dec 2010 17:47:19 +0900
  Subject: [PATCH] Deleting the same fdh twice is an error
  

Author:       discomfitor
Date:         2010-12-20 14:52:41 -0800 (Mon, 20 Dec 2010)
New Revision: 55676
Trac:         http://trac.enlightenment.org/e/changeset/55676

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-20 19:21:17 UTC (rev 55675)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-20 22:52:41 UTC (rev 55676)
@@ -826,8 +826,10 @@
         return NULL;
      }
    if (fd_handler->delete_me)
-     /* FIXME: should this return NULL instead? */
-     return fd_handler->data;
+     {
+        ERR("fdh %p deleted twice", fd_handler);
+        return NULL;
+     }
      
    fd_handler->delete_me = EINA_TRUE;
    _ecore_main_fdh_poll_del(fd_handler);

Log:
this adds a small helper function for use in finding cases where the epoll fd gets deleted and calls it after each fdh function
  if epoll support is not enabled, the function does nothing
  this will be removed prior to actual release, but will be very useful in finding the last epoll bugs until then
  

Author:       discomfitor
Date:         2010-12-31 19:07:58 -0800 (Fri, 31 Dec 2010)
New Revision: 55791
Trac:         http://trac.enlightenment.org/e/changeset/55791

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c trunk/ecore/src/lib/ecore/ecore_private.h 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2010-12-31 17:48:49 UTC (rev 55790)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-01 03:07:58 UTC (rev 55791)
@@ -154,7 +154,19 @@
 static gboolean ecore_fds_ready;
 #endif
 
+void
+_ecore_fd_valid(void)
+{
 #ifdef HAVE_EPOLL
+   if (fcntl(epoll_fd, F_GETFD) < 0)
+     {
+        ERR("arghhh you caught me! report a backtrace to edevel!");
+        sleep(5);
+     }
+#endif
+}
+
+#ifdef HAVE_EPOLL
 static inline int
 _ecore_get_epoll_fd(void)
 {
@@ -1307,6 +1319,7 @@
 
                     }
                   fdh->references--;
+                  _ecore_fd_valid();
 
                   fdh->read_active = EINA_FALSE;
                   fdh->write_active = EINA_FALSE;

Modified: trunk/ecore/src/lib/ecore/ecore_private.h
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_private.h	2010-12-31 17:48:49 UTC (rev 55790)
+++ trunk/ecore/src/lib/ecore/ecore_private.h	2011-01-01 03:07:58 UTC (rev 55791)
@@ -118,6 +118,7 @@
 EAPI void          _ecore_magic_fail(const void *d, Ecore_Magic m, Ecore_Magic req_m, const char *fname);
 
 void          _ecore_time_init(void);
+void          _ecore_fd_valid(void);
 
 void          _ecore_timer_shutdown(void);
 void          _ecore_timer_cleanup(void);

Log:
some updates to ecore_fd_valid: add dummy closes to track with strace (sup k-s) and switch sleep() to pause()
  

Author:       discomfitor
Date:         2011-01-03 22:58:34 -0800 (Mon, 03 Jan 2011)
New Revision: 55838
Trac:         http://trac.enlightenment.org/e/changeset/55838

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-04 06:10:31 UTC (rev 55837)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-04 06:58:34 UTC (rev 55838)
@@ -161,8 +161,11 @@
    if (fcntl(epoll_fd, F_GETFD) < 0)
      {
         ERR("arghhh you caught me! report a backtrace to edevel!");
-        sleep(5);
+        close(-111);
+        pause();
      }
+   else
+     close(-999);
 #endif
 }

Log:
remove dummy close() calls
  

Author:       discomfitor
Date:         2011-01-05 20:00:39 -0800 (Wed, 05 Jan 2011)
New Revision: 55924
Trac:         http://trac.enlightenment.org/e/changeset/55924

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-06 03:58:58 UTC (rev 55923)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-06 04:00:39 UTC (rev 55924)
@@ -161,11 +161,8 @@
    if (fcntl(epoll_fd, F_GETFD) < 0)
      {
         ERR("arghhh you caught me! report a backtrace to edevel!");
-        close(-111);
         pause();
      }
-   else
-     close(-999);
 #endif
 }

Log:
avoid passing NULL to exec functions
  

Author:       discomfitor
Date:         2011-01-13 18:25:55 -0800 (Thu, 13 Jan 2011)
New Revision: 56081
Trac:         http://trac.enlightenment.org/e/changeset/56081

Modified:
  trunk/ecore/src/lib/ecore/ecore_exe.c 

Modified: trunk/ecore/src/lib/ecore/ecore_exe.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_exe.c	2011-01-13 23:15:41 UTC (rev 56080)
+++ trunk/ecore/src/lib/ecore/ecore_exe.c	2011-01-14 02:25:55 UTC (rev 56081)
@@ -1500,6 +1500,14 @@
           }
      }
 
+   if ((!args) || (!args[0]))
+     {
+        IF_FREE(buf);
+        IF_FREE(args);
+        ERR("arg[0] is NULL!");
+        return;
+     }
+
    if (!(flags & ECORE_EXE_NOT_LEADER)) setsid();
    if ((flags & ECORE_EXE_USE_SH))
      {

Log:
avoid undefined array access
  

Author:       discomfitor
Date:         2011-01-13 19:11:00 -0800 (Thu, 13 Jan 2011)
New Revision: 56086
Trac:         http://trac.enlightenment.org/e/changeset/56086

Modified:
  trunk/ecore/src/lib/ecore/ecore_events.c 

Modified: trunk/ecore/src/lib/ecore/ecore_events.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_events.c	2011-01-14 02:57:52 UTC (rev 56085)
+++ trunk/ecore/src/lib/ecore/ecore_events.c	2011-01-14 03:11:00 UTC (rev 56086)
@@ -145,7 +145,7 @@
      }
    if (ecore_raw_event_type == type)
      event_handlers_add_list = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers_add_list), EINA_INLIST_GET(eh));
-   else
+   else if (type < event_handlers_alloc_num)
      event_handlers[type] = (Ecore_Event_Handler *)eina_inlist_append(EINA_INLIST_GET(event_handlers[type]), EINA_INLIST_GET(eh));
    return eh;
 }

Log:
more descriptive error messages when epoll fails
  @mike_m: should we replace this with strerror_r implementation?
  

Author:       discomfitor
Date:         2011-01-20 14:37:57 -0800 (Thu, 20 Jan 2011)
New Revision: 56247
Trac:         http://trac.enlightenment.org/e/changeset/56247

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-20 22:28:33 UTC (rev 56246)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-20 22:37:57 UTC (rev 56247)
@@ -767,7 +767,8 @@
    fdh->flags = flags;
    if (_ecore_main_fdh_poll_add(fdh) < 0)
      {
-        ERR("Failed to add poll on fd %d (errno = %d)!", fd, errno);
+        int err = errno;
+        ERR("Failed to add poll on fd %d (errno = %d: %s)!", fd, err, strerror(err));
         free(fdh);
         return NULL;
      }

Log:
add @file for doxy
  

Author:       discomfitor
Date:         2011-01-26 10:23:45 -0800 (Wed, 26 Jan 2011)
New Revision: 56309
Trac:         http://trac.enlightenment.org/e/changeset/56309

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2011-01-26 18:15:47 UTC (rev 56308)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2011-01-26 18:23:45 UTC (rev 56309)
@@ -50,6 +50,7 @@
 #endif
 
   /**
+   * @file Ecore.h
    * @defgroup Ecore_Group Ecore - Main Loop and Job Functions.
    * @brief The file that provides the program utility, main loop and timer
    *        functions.

Log:
unsigned int : 1 -> Eina_Bool : 1
  

Author:       discomfitor
Date:         2011-01-26 10:38:13 -0800 (Wed, 26 Jan 2011)
New Revision: 56310
Trac:         http://trac.enlightenment.org/e/changeset/56310

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2011-01-26 18:23:45 UTC (rev 56309)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2011-01-26 18:38:13 UTC (rev 56310)
@@ -265,9 +265,9 @@
 
    struct _Ecore_Event_Signal_Exit /** Exit request event */
      {
-        unsigned int   interrupt : 1; /**< Set if the exit request was an interrupt  signal*/
-        unsigned int   quit      : 1; /**< set if the exit request was a quit signal */
-        unsigned int   terminate : 1; /**< Set if the exit request was a terminate singal */
+        Eina_Bool   interrupt : 1; /**< Set if the exit request was an interrupt  signal*/
+        Eina_Bool   quit      : 1; /**< set if the exit request was a quit signal */
+        Eina_Bool   terminate : 1; /**< Set if the exit request was a terminate singal */
         void          *ext_data; /**< Extension data - not used */
 
 #ifndef _WIN32
@@ -305,8 +305,8 @@
         int           exit_code; /**< The exit code of the process */
         Ecore_Exe    *exe; /**< The handle to the exited process, or NULL if not found */
         int           exit_signal; /** < The signal that caused the process to exit */
-        unsigned int  exited    : 1; /** < set to 1 if the process exited of its own accord */
-        unsigned int  signalled : 1; /** < set to 1 id the process exited due to uncaught signal */
+        Eina_Bool  exited    : 1; /** < set to 1 if the process exited of its own accord */
+        Eina_Bool  signalled : 1; /** < set to 1 id the process exited due to uncaught signal */
         void         *ext_data; /**< Extension data - not used */
 #ifndef _WIN32
         siginfo_t     data; /**< Signal info */

Log:
From: Mike McCormack <mj.mccormack@...>
  Subject: [E-devel] [PATCH] ecore main loop "fd_handlers_to_call" list optimization
  Date: Thu, 02 Dec 2010 15:22:13 +0900
  
  Hi All,
  
  Rather than using malloc'ed list entries in the mail loop, use a single linked in-place list.
  
  This avoid lots of mallocs and frees as the main loop iterates.
  
  thanks,
  
  Mike
  

Author:       discomfitor
Date:         2011-01-28 21:34:00 -0800 (Fri, 28 Jan 2011)
New Revision: 56368
Trac:         http://trac.enlightenment.org/e/changeset/56368

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-29 05:25:42 UTC (rev 56367)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-01-29 05:34:00 UTC (rev 56368)
@@ -61,6 +61,7 @@
 {
    EINA_INLIST;
    ECORE_MAGIC;
+   Ecore_Fd_Handler        *next_ready;
    int                      fd;
    Ecore_Fd_Handler_Flags   flags;
    Ecore_Fd_Cb              func;
@@ -119,9 +120,9 @@
 static Eina_List        *fd_handlers_with_buffer = NULL;
 static Eina_List        *fd_handlers_to_delete = NULL;
 
-static Eina_List        *fd_handlers_to_call = NULL;
-static Eina_List        *fd_handlers_to_call_current;
-static Eina_List        *fd_handlers_to_call_current_next;
+/* single linked list of ready fdhs, terminated by loop to self */
+static Ecore_Fd_Handler    *fd_handlers_to_call;
+static Ecore_Fd_Handler    *fd_handlers_to_call_current;
 
 #ifdef _WIN32
 static Ecore_Win32_Handler *win32_handlers = NULL;
@@ -166,6 +167,24 @@
 #endif
 }
 
+static inline void
+_ecore_try_add_to_call_list(Ecore_Fd_Handler *fdh)
+{
+   /* check if this fdh is already in the list */
+   if (fdh->next_ready)
+     return;
+   if (fdh->read_active || fdh->write_active || fdh->error_active)
+     {
+        /*
+         * make sure next_ready is non-null by pointing to ourselves
+         * use that to indicate this fdh is in the ready list
+         * insert at the head of the list to avoid trouble
+         */
+        fdh->next_ready = fd_handlers_to_call ? fd_handlers_to_call : fdh;
+        fd_handlers_to_call = fdh;
+     }
+}
+
 #ifdef HAVE_EPOLL
 static inline int
 _ecore_get_epoll_fd(void)
@@ -332,7 +351,6 @@
    for (i = 0; i < ret; i++)
      {
         Ecore_Fd_Handler *fdh;
-        Eina_Bool pst, st;
 
         fdh = ev[i].data.ptr;
         if (!ECORE_MAGIC_CHECK(fdh, ECORE_MAGIC_FD_HANDLER))
@@ -346,15 +364,15 @@
              ERR("deleted fd in epoll");
              continue;
           }
-        pst = st = fdh->read_active | fdh->write_active | fdh->error_active;
-        if ((ev[i].events & EPOLLIN) && (!fdh->read_active))
-         st = fdh->read_active = EINA_TRUE;
-        if ((ev[i].events & EPOLLOUT) && (!fdh->write_active))
-         st = fdh->write_active = EINA_TRUE;
-        if ((ev[i].events & EPOLLERR) && (!fdh->error_active))
-         st = fdh->error_active = EINA_TRUE;
-        if (pst != st)
-          fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+
+        if (ev[i].events & EPOLLIN)
+          fdh->read_active = EINA_TRUE;
+        if (ev[i].events & EPOLLOUT)
+          fdh->write_active = EINA_TRUE;
+        if (ev[i].events & EPOLLERR)
+          fdh->error_active = EINA_TRUE;
+
+        _ecore_try_add_to_call_list(fdh);
      }
 
    return ret;
@@ -365,7 +383,6 @@
 static inline int _ecore_main_fdh_poll_mark_active(void)
 {
    Ecore_Fd_Handler *fdh;
-   Eina_Bool pst, st;
    int ret = 0;
 
    /* call the prepare callback for all handlers */
@@ -374,15 +391,15 @@
         if (fdh->delete_me)
            continue;
 
-        pst = st = fdh->read_active | fdh->write_active | fdh->error_active;
-        if ((fdh->gfd.revents & G_IO_IN) && (!fdh->read_active))
-         st = fdh->read_active = EINA_TRUE;
-        if ((fdh->gfd.revents & G_IO_OUT) && (!fdh->write_active))
-         st = fdh->write_active = EINA_TRUE;
-        if ((fdh->gfd.revents & G_IO_ERR) && (!fdh->error_active))
-         st = fdh->error_active = EINA_TRUE;
-        if (pst != st)
-          fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+        if (fdh->gfd.revents & G_IO_IN)
+           fdh->read_active = EINA_TRUE;
+        if (fdh->gfd.revents & G_IO_OUT)
+           fdh->write_active = EINA_TRUE;
+        if (fdh->gfd.revents & G_IO_ERR)
+           fdh->error_active = EINA_TRUE;
+
+        _ecore_try_add_to_call_list(fdh);
+
         if (fdh->gfd.revents & (G_IO_IN|G_IO_OUT|G_IO_ERR)) ret++;
      }
 
@@ -763,6 +780,7 @@
    fdh = calloc(1, sizeof(Ecore_Fd_Handler));
    if (!fdh) return NULL;
    ECORE_MAGIC_SET(fdh, ECORE_MAGIC_FD_HANDLER);
+   fdh->next_ready = NULL;
    fdh->fd = fd;
    fdh->flags = flags;
    if (_ecore_main_fdh_poll_add(fdh) < 0)
@@ -999,9 +1017,8 @@
      fd_handlers_with_prep = eina_list_free(fd_handlers_with_prep);
    if (fd_handlers_to_delete)
      fd_handlers_to_delete = eina_list_free(fd_handlers_to_delete);
-   if (fd_handlers_to_call)
-     fd_handlers_to_call = eina_list_free(fd_handlers_to_call);
 
+   fd_handlers_to_call = NULL;
    fd_handlers_to_call_current = NULL;
    fd_handlers_to_delete = NULL;
    fd_handler_current = NULL;
@@ -1140,16 +1157,13 @@
           {
              if (!fdh->delete_me)
                {
-                  Eina_Bool pst, st;
-                  pst = st = fdh->read_active | fdh->write_active | fdh->error_active;
-                  if ((FD_ISSET(fdh->fd, &rfds)) && (!fdh->read_active))
-                   st = fdh->read_active = EINA_TRUE;
-                  if ((FD_ISSET(fdh->fd, &wfds)) && (!fdh->write_active))
-                   st = fdh->write_active = EINA_TRUE;
-                  if ((FD_ISSET(fdh->fd, &exfds)) && (!fdh->error_active))
-                   st = fdh->error_active = EINA_TRUE;
-                  if (pst != st)
-                    fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
+                  if (FD_ISSET(fdh->fd, &rfds))
+                    fdh->read_active = EINA_TRUE;
+                  if (FD_ISSET(fdh->fd, &wfds))
+                    fdh->write_active = EINA_TRUE;
+                  if (FD_ISSET(fdh->fd, &exfds))
+                    fdh->error_active = EINA_TRUE;
+                  _ecore_try_add_to_call_list(fdh);
                }
           }
 #endif /* HAVE_EPOLL */
@@ -1286,22 +1300,16 @@
 static void
 _ecore_main_fd_handlers_call(void)
 {
+   /* grab a new list */
    if (!fd_handlers_to_call_current)
      {
-        /* regular main loop, start from head */
         fd_handlers_to_call_current = fd_handlers_to_call;
-        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current);
+        fd_handlers_to_call = NULL;
      }
-   else
-     {
-        /* recursive main loop, continue from where we were */
-        fd_handlers_to_call_current = fd_handlers_to_call_current_next;
-        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current);
-     }
 
    while (fd_handlers_to_call_current)
      {
-        Ecore_Fd_Handler *fdh = fd_handlers_to_call_current->data;
+        Ecore_Fd_Handler *fdh = fd_handlers_to_call_current;
 
         if (!fdh->delete_me)
           {
@@ -1328,9 +1336,16 @@
                }
           }
 
-        fd_handlers_to_call = eina_list_remove_list(fd_handlers_to_call, fd_handlers_to_call_current);
-        fd_handlers_to_call_current = fd_handlers_to_call_current_next;
-        fd_handlers_to_call_current_next = eina_list_next(fd_handlers_to_call_current_next);
+        /* stop when we point to ourselves */
+        if (fdh->next_ready == fdh)
+          {
+             fdh->next_ready = NULL;
+             fd_handlers_to_call_current = NULL;
+             break;
+          }
+
+        fd_handlers_to_call_current = fdh->next_ready;
+        fdh->next_ready = NULL;
      }
 }
 
@@ -1355,12 +1370,8 @@
              if (fdh->buf_func(fdh->buf_data, fdh))
                {
                   ret |= fdh->func(fdh->data, fdh);
-                  if (!fdh->read_active)
-                    {
-                       fdh->read_active = EINA_TRUE;
-                       if ((!fdh->write_active) && (!fdh->error_active))
-                         fd_handlers_to_call = eina_list_append(fd_handlers_to_call, fdh);
-                    }
+                  fdh->read_active = EINA_TRUE;
+                  _ecore_try_add_to_call_list(fdh);
                }
              fdh->references--;
           }

Log:
From: Mike McCormack <mj.mccormack@...>
  Subject: [E-devel] [PATCH] Remove SIGRT stuff
  
  Unused, and doesn't work as it stands.  Delete...
  

Author:       discomfitor
Date:         2011-02-01 17:27:24 -0800 (Tue, 01 Feb 2011)
New Revision: 56641
Trac:         http://trac.enlightenment.org/e/changeset/56641

Modified:
  trunk/ecore/src/lib/ecore/ecore_signal.c 

Modified: trunk/ecore/src/lib/ecore/ecore_signal.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_signal.c	2011-02-01 21:44:38 UTC (rev 56640)
+++ trunk/ecore/src/lib/ecore/ecore_signal.c	2011-02-02 01:27:24 UTC (rev 56641)
@@ -15,7 +15,6 @@
 /* make mono happy - this is evil though... */
 #undef SIGPWR
 /* valgrind in some versions/setups uses SIGRT's... hmmm */
-#undef SIGRTMIN
 
 typedef void (*Signal_Handler)(int sig, siginfo_t *si, void *foo);
 
@@ -32,10 +31,6 @@
 static void _ecore_signal_callback_sigpwr(int sig, siginfo_t *si, void *foo);
 #endif
 
-#ifdef SIGRTMIN
-static void _ecore_signal_callback_sigrt(int sig, siginfo_t *si, void *foo);
-#endif
-
 static Eina_Bool _ecore_signal_exe_exit_delay(void *data);
 
 //#define MAXSIGQ 256 // 32k
@@ -52,9 +47,6 @@
 #ifdef SIGPWR
 static volatile sig_atomic_t sigpwr_count = 0;
 #endif
-#ifdef SIGRTMIN
-static volatile sig_atomic_t *sigrt_count = NULL;
-#endif
 
 static volatile siginfo_t sigchld_info[MAXSIGQ];
 static volatile siginfo_t sigusr1_info[MAXSIGQ];
@@ -66,17 +58,10 @@
 #ifdef SIGPWR
 static volatile siginfo_t sigpwr_info[MAXSIGQ];
 #endif
-#ifdef SIGRTMIN
-static volatile siginfo_t *sigrt_info[MAXSIGQ];
-#endif
 
 void
 _ecore_signal_shutdown(void)
 {
-#ifdef SIGRTMIN
-   int i, num = SIGRTMAX - SIGRTMIN;
-#endif
-
    _ecore_signal_callback_set(SIGPIPE, (Signal_Handler) SIG_DFL);
    _ecore_signal_callback_set(SIGALRM, (Signal_Handler) SIG_DFL);
    _ecore_signal_callback_set(SIGCHLD, (Signal_Handler) SIG_DFL);
@@ -99,37 +84,11 @@
    sigterm_count = 0;
    sig_count = 0;
 
-#ifdef SIGRTMIN
-   for (i = 0; i < num; i++)
-     {
-        _ecore_signal_callback_set(SIGRTMIN + i, (Signal_Handler) SIG_DFL);
-        sigrt_count[i] = 0;
-     }
-
-   if (sigrt_count)
-     {
-        free((sig_atomic_t *) sigrt_count);
-        sigrt_count = NULL;
-     }
-
-   for (i = 0; i < MAXSIGQ; i++)
-     {
-        if (sigrt_info[i])
-          {
-             free((siginfo_t *) sigrt_info[i]);
-             sigrt_info[i] = NULL;
-          }
-     }
-#endif
 }
 
 void
 _ecore_signal_init(void)
 {
-#ifdef SIGRTMIN
-   int i, num = SIGRTMAX - SIGRTMIN;
-#endif
-
    _ecore_signal_callback_set(SIGPIPE, _ecore_signal_callback_ignore);
    _ecore_signal_callback_set(SIGALRM, _ecore_signal_callback_ignore);
    _ecore_signal_callback_set(SIGCHLD, _ecore_signal_callback_sigchld);
@@ -142,20 +101,6 @@
 #ifdef SIGPWR
    _ecore_signal_callback_set(SIGPWR,  _ecore_signal_callback_sigpwr);
 #endif
-
-#ifdef SIGRTMIN
-   sigrt_count = calloc(1, sizeof(sig_atomic_t) * num);
-   assert(sigrt_count);
-
-   for (i = 0; i < MAXSIGQ; i++)
-     {
-        sigrt_info[i] = calloc(1, sizeof(siginfo_t) * num);
-        assert(sigrt_info[i]);
-     }
-
-   for (i = 0; i < num; i++)
-      _ecore_signal_callback_set(SIGRTMIN + i, _ecore_signal_callback_sigrt);
-#endif
 }
 
 int
@@ -167,9 +112,6 @@
 void
 _ecore_signal_call(void)
 {
-#ifdef SIGRTMIN
-   int i, num = SIGRTMAX - SIGRTMIN;
-#endif
    volatile sig_atomic_t n;
    sigset_t oldset, newset;
 
@@ -187,10 +129,6 @@
 #ifdef SIGPWR
    sigaddset(&newset, SIGPWR);
 #endif
-#ifdef SIGRTMIN
-   for (i = 0; i < num; i++)
-     sigaddset(&newset, SIGRTMIN + i);
-#endif
    sigprocmask(SIG_BLOCK, &newset, &oldset);
    if (sigchld_count > MAXSIGQ)
      WRN("%i SIGCHLD in queue. max queue size %i. losing "
@@ -412,30 +350,6 @@
    sigpwr_count = 0;
 #endif
 
-#ifdef SIGRTMIN
-   for (i = 0; i < num; i++)
-     {
-        if (sigrt_count[i] > MAXSIGQ)
-          WRN("%i SIGRT%i in queue. max queue size %i. losing "
-              "siginfo for extra signals.", i + 1, sigrt_count[i], MAXSIGQ);
-        for (n = 0; n < sigrt_count[i]; n++)
-          {
-             Ecore_Event_Signal_Realtime *e;
-
-             if ((e = _ecore_event_signal_realtime_new()))
-               {
-                  e->num = i;
-
-                  if ((n < MAXSIGQ) && (sigrt_info[n][i].si_signo))
-                    e->data = sigrt_info[n][i];
-
-                  ecore_event_add(ECORE_EVENT_SIGNAL_REALTIME, e, NULL, NULL);
-               }
-             sig_count--;
-          }
-        sigrt_count[i] = 0;
-     }
-#endif
    sigprocmask(SIG_SETMASK, &oldset, NULL);
 }
 
@@ -586,24 +500,6 @@
 }
 #endif
 
-#ifdef SIGRTMIN
-static void
-_ecore_signal_callback_sigrt(int sig, siginfo_t *si, void *foo __UNUSED__)
-{
-   volatile sig_atomic_t n;
-   n = sigrt_count[sig - SIGRTMIN];
-   if (n < MAXSIGQ)
-     {
-        if (si)
-          sigrt_info[n][sig - SIGRTMIN] = *si;
-        else
-          sigrt_info[n][sig - SIGRTMIN].si_signo = 0;
-     }
-   sigrt_count[sig - SIGRTMIN]++;
-   sig_count++;
-}
-#endif
-
 static Eina_Bool
 _ecore_signal_exe_exit_delay(void *data)
 {

Log:
add more descriptive error messages for epoll flag mod failure
  

Author:       discomfitor
Date:         2011-02-15 11:51:06 -0800 (Tue, 15 Feb 2011)
New Revision: 57063
Trac:         http://trac.enlightenment.org/e/changeset/57063

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-02-15 18:58:02 UTC (rev 57062)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-02-15 19:51:06 UTC (rev 57063)
@@ -970,6 +970,8 @@
 EAPI void
 ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler, Ecore_Fd_Handler_Flags flags)
 {
+   int ret;
+
    if (!ECORE_MAGIC_CHECK(fd_handler, ECORE_MAGIC_FD_HANDLER))
      {
         ECORE_MAGIC_FAIL(fd_handler, ECORE_MAGIC_FD_HANDLER,
@@ -977,9 +979,10 @@
         return;
      }
    fd_handler->flags = flags;
-   if (_ecore_main_fdh_poll_modify(fd_handler) < 0)
+   ret = _ecore_main_fdh_poll_modify(fd_handler);
+   if (ret < 0)
      {
-        ERR("Failed to mod epoll fd %d!", fd_handler->fd);
+        ERR("Failed to mod epoll fd %d: %s!", fd_handler->fd, strerror(ret));
      }
 }

Log:
add main loop group to main docs page
  

Author:       discomfitor
Date:         2011-09-14 07:20:13 -0700 (Wed, 14 Sep 2011)
New Revision: 63387
Trac:         http://trac.enlightenment.org/e/changeset/63387

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2011-09-14 14:12:13 UTC (rev 63386)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2011-09-14 14:20:13 UTC (rev 63387)
@@ -19,6 +19,7 @@
 it can be found in @ref Ecore_Main_Loop_Page.
 
 The Ecore library provides the following modules:
+@li @ref Ecore_Main_Loop_Group
 @li @ref Ecore_File_Group
 @li @ref Ecore_Con_Group
 @li @link Ecore_Evas.h   Ecore_Evas - Evas convenience functions. @endlink

Log:
fix docs for ecore_main_fd_handler_del
  

Author:       discomfitor
Date:         2011-09-14 07:26:28 -0700 (Wed, 14 Sep 2011)
New Revision: 63388
Trac:         http://trac.enlightenment.org/e/changeset/63388

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-09-14 14:20:13 UTC (rev 63387)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-09-14 14:26:28 UTC (rev 63388)
@@ -1019,16 +1019,18 @@
 
 
 /**
- * Deletes the given FD handler.
- * @param   fd_handler The given FD handler.
+ * Marks an FD handler for deletion.
+ * @param   fd_handler The FD handler.
  * @return  The data pointer set using @ref ecore_main_fd_handler_add,
  *          for @p fd_handler on success.  @c NULL otherwise.
  * @ingroup Ecore_FD_Handler_Group
+ * This function marks an fd handler to be deleted during an iteration of the main loop.
+ * It does NOT close the associated fd!
  *
- * Beware that if the fd is already closed, ecore may complain if it uses
- * epoll internally, and that in some rare cases this may be able to cause
+ * @note If the underlying fd is already closed ecore may complain if the main loop
+ * is using epoll internally, and also in some rare cases this may cause
  * crashes and instability. Remember to delete your fd handlers before the
- * fd's they listen to are closed.
+ * fds they listen to are closed.
  */
 EAPI void *
 ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)

Log:
fix and clarify more fd handler docs
  

Author:       discomfitor
Date:         2011-09-14 07:31:54 -0700 (Wed, 14 Sep 2011)
New Revision: 63389
Trac:         http://trac.enlightenment.org/e/changeset/63389

Modified:
  trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2011-09-14 14:26:28 UTC (rev 63388)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2011-09-14 14:31:54 UTC (rev 63389)
@@ -920,17 +920,17 @@
  * @p func will be called during the execution of @ref ecore_main_loop_begin
  * when the file descriptor is available for reading, or writing, or both.
  *
- * Normally the return value from the @p func is "zero means this handler is
- * finished and can be deleted" as is usual for handler callbacks.  However,
- * if the @p buf_func is supplied, then the return value from the @p func is
- * "non zero means the handler should be called again in a tight loop".
+ * Normally when @p func returns ECORE_CALLBACK_CANCEL, it indicates that the
+ * handler should be marked for deletion (identical to calling @ref ecore_main_fd_handler_del).
+ * However, if the @p buf_func is supplied, then the return value from the @p func indicates that
+ * @p func should be called repeatedly until it returns ECORE_CALLBACK_CANCEL.
  *
  * @p buf_func is called during event loop handling to check if data that has
  * been read from the file descriptor is in a buffer and is available to
  * read.  Some systems (notably xlib) handle their own buffering, and would
  * otherwise not work with select().  These systems should use a @p buf_func.
  * This is a most annoying hack, only ecore_x uses it, so refer to that for
- * an example.  NOTE - @p func should probably return "one" always if
+ * an example.  NOTE - @p func should probably return ECORE_CALLBACK_RENEW always if
  * @p buf_func is used, to avoid confusion with the other return value
  * semantics.
  *
@@ -944,6 +944,7 @@
  *                   buffered and already read from the fd.  Can be @c NULL.
  * @param   buf_data The data to pass to the @p buf_func function.
  * @return  A fd handler handle if successful.  @c NULL otherwise.
+ * @note This function CANNOT be used for reading/writing to regular files!
  * @ingroup Ecore_FD_Handler_Group
  */
 EAPI Ecore_Fd_Handler *

Log:
#undef header macro
  

Author:       discomfitor
Date:         2011-12-02 19:42:41 -0800 (Fri, 02 Dec 2011)
New Revision: 65834
Trac:         http://trac.enlightenment.org/e/changeset/65834

Modified:
  trunk/ecore/src/lib/ecore/ecore_private.h 

Modified: trunk/ecore/src/lib/ecore/ecore_private.h
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_private.h	2011-12-03 03:39:07 UTC (rev 65833)
+++ trunk/ecore/src/lib/ecore/ecore_private.h	2011-12-03 03:42:41 UTC (rev 65834)
@@ -373,4 +373,6 @@
 GENERIC_ALLOC_FREE_HEADER(Ecore_Win32_Handler, ecore_win32_handler);
 #endif
 
+#undef GENERIC_ALLOC_FREE_HEADER
+
 #endif

Log:
unfuck header formatting
  

Author:       discomfitor
Date:         2011-12-04 15:01:36 -0800 (Sun, 04 Dec 2011)
New Revision: 65874
Trac:         http://trac.enlightenment.org/e/changeset/65874

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2011-12-04 22:53:22 UTC (rev 65873)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2011-12-04 23:01:36 UTC (rev 65874)
@@ -315,10 +315,8 @@
  * @{
  */
 
-EAPI int
- ecore_init(void);
-EAPI int
- ecore_shutdown(void);
+EAPI int ecore_init(void);
+EAPI int ecore_shutdown(void);
 
 /**
  * @}
@@ -395,23 +393,16 @@
  */
 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
@@ -441,9 +432,7 @@
  * 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.
@@ -460,9 +449,7 @@
  * 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
@@ -482,8 +469,7 @@
  * 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.
@@ -496,8 +482,7 @@
  * 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);
 
 /**
  * @}
@@ -631,37 +616,17 @@
 #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);
 
 /**
  * @}
@@ -702,11 +667,11 @@
 
 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;
@@ -759,72 +724,32 @@
    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);
 
 /**
  * @}
@@ -839,7 +764,7 @@
  * 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
@@ -888,34 +813,15 @@
  */
 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_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_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);
 
 /**
  * @}
@@ -946,21 +852,11 @@
 
 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);
 
 /**
@@ -984,14 +880,14 @@
  *    ... 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.
@@ -1057,8 +953,7 @@
  * @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
  *
@@ -1086,10 +981,7 @@
  * @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.
  *
@@ -1103,8 +995,7 @@
  * 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.
  *
@@ -1115,12 +1006,11 @@
  *
  * @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.
  *
@@ -1129,8 +1019,7 @@
  * 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.
  *
@@ -1144,8 +1033,7 @@
  *
  * @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.
  *
@@ -1155,8 +1043,7 @@
  *
  * @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.
@@ -1217,11 +1104,7 @@
  *
  * @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
  *
@@ -1238,14 +1121,13 @@
  * 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.
  *
@@ -1255,8 +1137,7 @@
  *
  * @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
  *
@@ -1266,7 +1147,7 @@
  * 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
@@ -1276,9 +1157,7 @@
  * @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
  *
@@ -1286,18 +1165,16 @@
  * @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
  *
@@ -1311,8 +1188,7 @@
  * @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);
 
 /**
  * @}
@@ -1338,43 +1214,22 @@
 
 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 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 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);
 
 /**
  * @}
@@ -1443,9 +1298,7 @@
  *
  * 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.
@@ -1453,23 +1306,14 @@
  * @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);
 
 /**
  * @}
@@ -1525,7 +1369,7 @@
  *
  * 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.
  *
@@ -1611,7 +1455,7 @@
  * 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
@@ -1636,11 +1480,7 @@
  * @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
  *
@@ -1681,13 +1521,9 @@
  * @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.
  *
@@ -1709,9 +1545,9 @@
  * @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
@@ -1723,8 +1559,7 @@
  *
  * @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
  *
@@ -1744,8 +1579,7 @@
  *
  * @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
  *
@@ -1767,9 +1601,7 @@
  *
  * @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
  *
@@ -1793,8 +1625,7 @@
  * 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
  *
@@ -1808,8 +1639,7 @@
  * 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
  *
@@ -1818,8 +1648,7 @@
  * 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
  *
@@ -1828,18 +1657,16 @@
  * 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
  *
@@ -1847,7 +1674,7 @@
  *
  * 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.
  *
@@ -1858,8 +1685,7 @@
  * @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
  *
@@ -1872,8 +1698,7 @@
  * @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
  *
@@ -1883,8 +1708,7 @@
  * @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
  *
@@ -1896,8 +1720,7 @@
  * 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
  *
@@ -1970,7 +1793,7 @@
  * 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
@@ -1982,12 +1805,8 @@
  * @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
  *
@@ -2015,11 +1834,7 @@
  * @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
  *
@@ -2037,9 +1852,7 @@
  * @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
  *
@@ -2064,9 +1877,7 @@
  *
  * @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
@@ -2096,7 +1907,7 @@
  * 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
@@ -2106,11 +1917,7 @@
  * @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
  *
@@ -2132,10 +1939,7 @@
  * @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
  *
@@ -2152,8 +1956,7 @@
  * @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
  *
@@ -2176,8 +1979,7 @@
  *
  * @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
  *
@@ -2190,7 +1992,7 @@
  * 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
@@ -2205,9 +2007,7 @@
  * @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);
 
 /**
  * @}
@@ -2242,27 +2042,14 @@
  */
 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);
 
 /**
  * @}
@@ -2294,11 +2081,8 @@
 
 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);
 
 /**
  * @}
@@ -2310,14 +2094,9 @@
  * @{
  */
 
-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);
 
 /**
  * @}
@@ -2331,10 +2110,8 @@
  * @{
  */
 
-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);
 
 /**
  * @}

Log:
totally meant to write this wrong the first time to see if anyone was watching.
  

Author:       discomfitor
Date:         2011-12-04 15:54:41 -0800 (Sun, 04 Dec 2011)
New Revision: 65878
Trac:         http://trac.enlightenment.org/e/changeset/65878

Modified:
  trunk/ecore/src/lib/ecore/ecore_timer.c 

Modified: trunk/ecore/src/lib/ecore/ecore_timer.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_timer.c	2011-12-04 23:16:25 UTC (rev 65877)
+++ trunk/ecore/src/lib/ecore/ecore_timer.c	2011-12-04 23:54:41 UTC (rev 65878)
@@ -285,7 +285,7 @@
      add = timer->pending;
    else
      add = timer->at - now;
-   _ecore_timer_delay(timer, add);
+   _ecore_timer_delay(timer, timer->in - add);
    _ecore_unlock();
 }

Log:
#if 0 out an unused function
  

Author:       discomfitor
Date:         2012-02-25 00:30:51 -0800 (Sat, 25 Feb 2012)
New Revision: 68437
Trac:         http://trac.enlightenment.org/e/changeset/68437

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2012-02-25 08:21:24 UTC (rev 68436)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2012-02-25 08:30:51 UTC (rev 68437)
@@ -365,10 +365,12 @@
    _ecore_thread_kill(work);
 }
 
+#if 0
 static void
 _ecore_nothing_handler(void *data __UNUSED__, void *buffer __UNUSED__, unsigned int nbyte __UNUSED__)
 {
 }
+#endif
 
 static void
 _ecore_notify_handler(void *data)

Log:
don't return value in void functions
  

Author:       discomfitor
Date:         2012-06-06 03:52:45 -0700 (Wed, 06 Jun 2012)
New Revision: 71742
Trac:         http://trac.enlightenment.org/e/changeset/71742

Modified:
  trunk/ecore/src/lib/ecore/ecore_thread.c 

Modified: trunk/ecore/src/lib/ecore/ecore_thread.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_thread.c	2012-06-06 10:37:44 UTC (rev 71741)
+++ trunk/ecore/src/lib/ecore/ecore_thread.c	2012-06-06 10:52:45 UTC (rev 71742)
@@ -1251,7 +1251,7 @@
 EAPI void
 ecore_thread_max_reset(void)
 {
-   EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
+   EINA_MAIN_LOOP_CHECK_RETURN;
    _ecore_thread_count_max = eina_cpu_count();
 }

Log:
add ecore_main_fd_handler_file_add() for use with regular files.
  epoll does not handle reading from files since it is only a mechanism for determining whether a fd is ready for read/write/error, and regular files are always ready. as a result, we must select on them explicitly without adding to the epoll fd
  
  I realize that this is a feature freeze, but it's rather non-invasive and this is an absolute must-have to fix mounting for e17 so...sorry!
  

Author:       discomfitor
Date:         2012-08-01 07:37:24 -0700 (Wed, 01 Aug 2012)
New Revision: 74741
Trac:         http://trac.enlightenment.org/e/changeset/74741

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h trunk/ecore/src/lib/ecore/ecore_main.c 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2012-08-01 14:32:26 UTC (rev 74740)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2012-08-01 14:37:24 UTC (rev 74741)
@@ -1085,7 +1085,27 @@
  *
  */
 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);
+
 /**
+ * @brief Adds a callback for activity on the given file descriptor.
+ *
+ * @param fd The file descriptor to watch.
+ * @param flags To monitor it for reading use @c ECORE_FD_READ, for writing @c
+ * ECORE_FD_WRITE, and for error @c ECORE_FD_ERROR. Values by |(ored).
+ * @param func The callback function.
+ * @param data The data to pass to the callback.
+ * @param buf_func The function to call to check if any data has been buffered
+ * and already read from the fd. May be @c NULL.
+ * @param buf_data The data to pass to the @p buf_func function.
+ * @return A fd handler handle on success, @c NULL otherwise.
+ *
+ * This function is identical to ecore_main_fd_handler_add, except that it supports regular files.
+ *
+ * @since 1.7
+ */
+EAPI Ecore_Fd_Handler *ecore_main_fd_handler_file_add(int fd, Ecore_Fd_Handler_Flags flags, Ecore_Fd_Cb func, const void *data, Ecore_Fd_Cb buf_func, const void *buf_data);
+
+/**
  * @brief Set the prepare callback with data for a given #Ecore_Fd_Handler
  *
  * @param fd_handler The fd handler

Modified: trunk/ecore/src/lib/ecore/ecore_main.c
===================================================================
--- trunk/ecore/src/lib/ecore/ecore_main.c	2012-08-01 14:32:26 UTC (rev 74740)
+++ trunk/ecore/src/lib/ecore/ecore_main.c	2012-08-01 14:37:24 UTC (rev 74741)
@@ -163,6 +163,7 @@
    Eina_Bool              write_active : 1;
    Eina_Bool              error_active : 1;
    Eina_Bool              delete_me : 1;
+   Eina_Bool              file : 1;
 #if defined(USE_G_MAIN_LOOP)
    GPollFD                gfd;
 #endif
@@ -213,6 +214,7 @@
 static Ecore_Fd_Handler *fd_handlers = NULL;
 static Ecore_Fd_Handler *fd_handler_current = NULL;
 static Eina_List *fd_handlers_with_prep = NULL;
+static Eina_List *file_fd_handlers = NULL;
 static Eina_List *fd_handlers_with_buffer = NULL;
 static Eina_List *fd_handlers_to_delete = NULL;
 
@@ -326,7 +328,7 @@
    int events = 0;
    if (fdh->flags & ECORE_FD_READ) events |= EPOLLIN;
    if (fdh->flags & ECORE_FD_WRITE) events |= EPOLLOUT;
-   if (fdh->flags & ECORE_FD_ERROR) events |= EPOLLERR;
+   if (fdh->flags & ECORE_FD_ERROR) events |= EPOLLERR | EPOLLPRI;
    return events;
 }
 
@@ -348,7 +350,7 @@
 {
    int r = 0;
 
-   if (HAVE_EPOLL && epoll_fd >= 0)
+   if ((!fdh->file) && HAVE_EPOLL && epoll_fd >= 0)
      {
         r = _ecore_epoll_add(_ecore_get_epoll_fd(), fdh->fd,
                              _ecore_poll_events_from_fdh(fdh), fdh);
@@ -369,7 +371,7 @@
 static inline void
 _ecore_main_fdh_poll_del(Ecore_Fd_Handler *fdh)
 {
-   if (HAVE_EPOLL && epoll_fd >= 0)
+   if ((!fdh->file) && HAVE_EPOLL && epoll_fd >= 0)
      {
         struct epoll_event ev;
         int efd = _ecore_get_epoll_fd();
@@ -408,7 +410,7 @@
 _ecore_main_fdh_poll_modify(Ecore_Fd_Handler *fdh)
 {
    int r = 0;
-   if (HAVE_EPOLL && epoll_fd >= 0)
+   if ((!fdh->file) && HAVE_EPOLL && epoll_fd >= 0)
      {
         struct epoll_event ev;
         int efd = _ecore_get_epoll_fd();
@@ -1041,6 +1043,56 @@
    return fdh;
 }
 
+EAPI Ecore_Fd_Handler *
+ecore_main_fd_handler_file_add(int                    fd,
+                               Ecore_Fd_Handler_Flags flags,
+                               Ecore_Fd_Cb            func,
+                               const void            *data,
+                               Ecore_Fd_Cb            buf_func,
+                               const void            *buf_data)
+{
+   Ecore_Fd_Handler *fdh = NULL;
+
+   EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
+   _ecore_lock();
+
+   if ((fd < 0) || (flags == 0) || (!func)) goto unlock;
+
+   fdh = ecore_fd_handler_calloc(1);
+   if (!fdh) goto unlock;
+   ECORE_MAGIC_SET(fdh, ECORE_MAGIC_FD_HANDLER);
+   fdh->next_ready = NULL;
+   fdh->fd = fd;
+   fdh->flags = flags;
+   fdh->file = EINA_TRUE;
+   if (_ecore_main_fdh_poll_add(fdh) < 0)
+     {
+        int err = errno;
+        ERR("Failed to add poll on fd %d (errno = %d: %s)!", fd, err, strerror(err));
+        ecore_fd_handler_mp_free(fdh);
+        fdh = NULL;
+        goto unlock;
+     }
+   fdh->read_active = EINA_FALSE;
+   fdh->write_active = EINA_FALSE;
+   fdh->error_active = EINA_FALSE;
+   fdh->delete_me = EINA_FALSE;
+   fdh->func = func;
+   fdh->data = (void *)data;
+   fdh->buf_func = buf_func;
+   if (buf_func)
+     fd_handlers_with_buffer = eina_list_append(fd_handlers_with_buffer, fdh);
+   fdh->buf_data = (void *)buf_data;
+   fd_handlers = (Ecore_Fd_Handler *)
+     eina_inlist_append(EINA_INLIST_GET(fd_handlers),
+                        EINA_INLIST_GET(fdh));
+   file_fd_handlers = eina_list_append(file_fd_handlers, fdh);
+unlock:
+   _ecore_unlock();
+
+   return fdh;
+}
+
 #ifdef _WIN32
 EAPI Ecore_Win32_Handler *
 ecore_main_win32_handler_add(void                 *h,
@@ -1243,6 +1295,8 @@
      fd_handlers_with_prep = eina_list_free(fd_handlers_with_prep);
    if (fd_handlers_to_delete)
      fd_handlers_to_delete = eina_list_free(fd_handlers_to_delete);
+   if (file_fd_handlers)
+     file_fd_handlers = eina_list_free(file_fd_handlers);
 
    fd_handlers_to_call = NULL;
    fd_handlers_to_call_current = NULL;
@@ -1296,6 +1350,8 @@
 {
    struct timeval tv, *t;
    fd_set rfds, wfds, exfds;
+   Ecore_Fd_Handler *fdh;
+   Eina_List *l;
    int max_fd;
    int ret;
 
@@ -1333,8 +1389,6 @@
 
    if (!HAVE_EPOLL || epoll_fd < 0)
      {
-        Ecore_Fd_Handler *fdh;
-
         EINA_INLIST_FOREACH(fd_handlers, fdh)
           {
              if (!fdh->delete_me)
@@ -1363,7 +1417,26 @@
          max_fd = _ecore_get_epoll_fd();
          FD_SET(max_fd, &rfds);
      }
-
+   EINA_LIST_FOREACH(file_fd_handlers, l, fdh)
+     if (!fdh->delete_me)
+       {
+          if (fdh->flags & ECORE_FD_READ)
+            {
+               FD_SET(fdh->fd, &rfds);
+               if (fdh->fd > max_fd) max_fd = fdh->fd;
+            }
+          if (fdh->flags & ECORE_FD_WRITE)
+            {
+               FD_SET(fdh->fd, &wfds);
+               if (fdh->fd > max_fd) max_fd = fdh->fd;
+            }
+          if (fdh->flags & ECORE_FD_ERROR)
+            {
+               FD_SET(fdh->fd, &exfds);
+               if (fdh->fd > max_fd) max_fd = fdh->fd;
+            }
+          if (fdh->fd > max_fd) max_fd = fdh->fd;
+       }
    if (_ecore_signal_count_get()) return -1;
 
    _ecore_unlock();
@@ -1401,7 +1474,17 @@
                     }
                }
           }
-
+        EINA_LIST_FOREACH(file_fd_handlers, l, fdh)
+          if (!fdh->delete_me)
+            {
+               if (FD_ISSET(fdh->fd, &rfds))
+                 fdh->read_active = EINA_TRUE;
+               if (FD_ISSET(fdh->fd, &wfds))
+                 fdh->write_active = EINA_TRUE;
+               if (FD_ISSET(fdh->fd, &exfds))
+                 fdh->error_active = EINA_TRUE;
+               _ecore_try_add_to_call_list(fdh);
+            }
         _ecore_main_fd_handlers_cleanup();
 #ifdef _WIN32
         _ecore_main_win32_handlers_cleanup();
@@ -1498,6 +1581,8 @@
           fd_handlers_with_prep = eina_list_remove(fd_handlers_with_prep, fdh);
         fd_handlers = (Ecore_Fd_Handler *)
           eina_inlist_remove(EINA_INLIST_GET(fd_handlers), EINA_INLIST_GET(fdh));
+        if (fdh->file)
+          file_fd_handlers = eina_list_remove(file_fd_handlers, fdh);
         ECORE_MAGIC_SET(fdh, ECORE_MAGIC_NONE);
         ecore_fd_handler_mp_free(fdh);
         fd_handlers_to_delete = eina_list_remove_list(fd_handlers_to_delete, l);

Log:
add more docs for new ecore fdh function
  

Author:       discomfitor
Date:         2012-08-05 23:54:21 -0700 (Sun, 05 Aug 2012)
New Revision: 74898
Trac:         http://trac.enlightenment.org/e/changeset/74898

Modified:
  trunk/ecore/src/lib/ecore/Ecore.h 

Modified: trunk/ecore/src/lib/ecore/Ecore.h
===================================================================
--- trunk/ecore/src/lib/ecore/Ecore.h	2012-08-06 06:43:59 UTC (rev 74897)
+++ trunk/ecore/src/lib/ecore/Ecore.h	2012-08-06 06:54:21 UTC (rev 74898)
@@ -1100,6 +1100,9 @@
  * @return A fd handler handle on success, @c NULL otherwise.
  *
  * This function is identical to ecore_main_fd_handler_add, except that it supports regular files.
+ * @warning This function should ONLY be called with ECORE_FD_ERROR, otherwise it will call the fd
+ * handler constantly.
+ * @warning Do not use this function unless you know what you are doing.
  *
  * @since 1.7
  */