Include gerror.h before it is used for some g_thread_* functions.

[platform/upstream/glib.git] / glib.h

diff --git a/glib.h b/glib.h
index 6b68408..567bf59 100644 (file)
--- a/glib.h
+++ b/glib.h
@@ -941,6 +941,15 @@ struct _GTuples
   guint len;
 };
 
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#include <gerror.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
 
 /* IEEE Standard 754 Single Precision Storage Format (gfloat):
  *
@@ -2921,34 +2930,47 @@ gint        g_io_channel_unix_get_fd (GIOChannel *channel);
 
 #define G_WIN32_MSG_HANDLE 19981206
 
-/* This can be used to wait until a channel is readable.  On Unix you
- * would do a select() on the fd of the channel. This should probably
- * be replaced by something for all platforms?
+/* Use this to get a GPollFD from a GIOChannel, so that you can call
+ * g_io_channel_win32_poll(). After calling this you should only use
+ * g_io_channel_read() to read from the GIOChannel, i.e. never read()
+ * or recv() from the underlying file descriptor or SOCKET.
  */
-gint        g_io_channel_win32_wait_for_condition (GIOChannel  *channel,
-                                                  GIOCondition condition,
-                                                  gint         timeout);
+void        g_io_channel_win32_make_pollfd (GIOChannel   *channel,
+                                           GIOCondition  condition,
+                                           GPollFD      *fd);
+
+/* This can be used to wait a until at least one of the channels is readable.
+ * On Unix you would do a select() on the file descriptors of the channels.
+ * This should probably be available for all platforms?
+ */
+gint        g_io_channel_win32_poll   (GPollFD    *fds,
+                                      gint        n_fds,
+                                      gint        timeout);
 
 /* This is used to add polling for Windows messages. GDK (GTk+) programs
  * should *not* use this.
  */
-void        g_main_poll_win32_msg_add(gint        priority,
-                                     GPollFD    *fd,
-                                     guint       hwnd);
+void        g_main_poll_win32_msg_add (gint        priority,
+                                      GPollFD    *fd,
+                                      guint       hwnd);
 
 /* An IO channel for Windows messages for window handle hwnd. */
 GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
 
 /* An IO channel for C runtime (emulated Unix-like) file
  * descriptors. Identical to g_io_channel_unix_new above.
+ * After calling g_io_add_watch() on a IO channel returned
+ * by this function, you shouldn't call read() on the file
+ * descriptor.
  */
 GIOChannel* g_io_channel_win32_new_fd (int         fd);
 
 /* Get the C runtime file descriptor of a channel. */
 gint        g_io_channel_win32_get_fd (GIOChannel *channel);
 
-/* An IO channel for a SOCK_STREAM winsock socket. The parameter should
- * be a SOCKET.
+/* An IO channel for a SOCK_STREAM winsock socket. The parameter
+ * should be a SOCKET. After calling g_io_add_watch() on a IO channel
+ * returned by this function, you shouldn't call recv() on the SOCKET.
  */
 GIOChannel *g_io_channel_win32_new_stream_socket (int socket);
 
@@ -3034,6 +3056,14 @@ gchar *         g_win32_error_message (gint error);
 /* GLib Thread support
  */
 
+extern GQuark g_thread_error_quark();
+#define G_THREAD_ERROR g_thread_error_quark()
+
+typedef enum
+{
+  G_THREAD_ERROR_AGAIN /* Resource temporarily unavailable */
+} GThreadError;
+
 typedef void           (*GThreadFunc)          (gpointer       value);
 
 typedef enum
@@ -3086,7 +3116,8 @@ struct _GThreadFunctions
                                   gboolean              joinable,
                                   gboolean              bound,
                                   GThreadPriority       priority,
-                                  gpointer              thread);
+                                  gpointer              thread,
+                                  GError              **error);
   void      (*thread_yield)       (void);
   void      (*thread_join)        (gpointer             thread);
   void      (*thread_exit)        (void);
@@ -3148,11 +3179,12 @@ GThread* g_thread_create (GThreadFunc            thread_func,
                          gulong                 stack_size,
                          gboolean               joinable,
                          gboolean               bound,
-                         GThreadPriority        priority);
+                         GThreadPriority        priority,
+                         GError               **error);
 GThread* g_thread_self ();
-void g_thread_join (GThread* thread);
-void g_thread_set_priority (GThread* thread, 
-                           GThreadPriority priority);
+void g_thread_join (GThread *thread);
+void g_thread_set_priority (GThread         *thread, 
+                           GThreadPriority  priority);
 
 /* GStaticMutexes can be statically initialized with the value
  * G_STATIC_MUTEX_INIT, and then they can directly be used, that is
@@ -3352,20 +3384,23 @@ GThreadPool*    g_thread_pool_new             (GFunc            thread_func,
                                               gboolean         bound,
                                               GThreadPriority  priority,
                                               gboolean         exclusive,
-                                              gpointer         user_data);
+                                              gpointer         user_data,
+                                              GError         **error);
 
 /* Push new data into the thread pool. This task is assigned to a thread later
  * (when the maximal number of threads is reached for that pool) or now
  * (otherwise). If necessary a new thread will be started. The function
  * returns immediatly */
 void            g_thread_pool_push            (GThreadPool     *pool,
-                                              gpointer         data);
+                                              gpointer         data,
+                                              GError         **error);
 
 /* Set the number of threads, which can run concurrently for that pool, -1
  * means no limit. 0 means has the effect, that the pool won't process
  * requests until the limit is set higher again */
 void            g_thread_pool_set_max_threads (GThreadPool     *pool,
-                                              gint             max_threads);
+                                              gint             max_threads,
+                                              GError         **error);
 gint            g_thread_pool_get_max_threads (GThreadPool     *pool);
 
 /* Get the number of threads assigned to that pool. This number doesn't
@@ -3397,6 +3432,5 @@ void            g_thread_pool_stop_unused_threads    (void);
 #endif /* __cplusplus */
 
 #include <gunicode.h>
-#include <gerror.h>
 
 #endif /* __G_LIB_H__ */