atk 0.90.4-x86-mingw32 → 0.90.5-x86-mingw32

data/vendor/local/include/glib-2.0/glib/gcache.h

@@ -8,7 +8,7 @@
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public

data/vendor/local/include/glib-2.0/glib/gchecksum.h

@@ -38,8 +38,8 @@ G_BEGIN_DECLS
  * The hashing algorithm to be used by #GChecksum when performing the
  * digest of some data.
  *
- * Note that the #GChecksumType enumeration may be extended at a later 
- * date to include new hashing algorithm types. 
+ * Note that the #GChecksumType enumeration may be extended at a later
+ * date to include new hashing algorithm types.
  *
  * Since: 2.16
  */
@@ -60,26 +60,26 @@ typedef enum {
  */
 typedef struct _GChecksum       GChecksum;
 
-gssize                g_checksum_type_get_length (GChecksumType checksum_type);
+gssize                g_checksum_type_get_length    (GChecksumType    checksum_type);
 
-GChecksum *           g_checksum_new        (GChecksumType     checksum_type);
-void                  g_checksum_reset      (GChecksum        *checksum);
-GChecksum *           g_checksum_copy       (const GChecksum  *checksum);
-void                  g_checksum_free       (GChecksum        *checksum);
-void                  g_checksum_update     (GChecksum        *checksum,
-                                             const guchar     *data,
-                                             gssize            length);
-G_CONST_RETURN gchar *g_checksum_get_string (GChecksum        *checksum);
-void                  g_checksum_get_digest (GChecksum        *checksum,
-                                             guint8           *buffer,
-                                             gsize            *digest_len);
+GChecksum *           g_checksum_new                (GChecksumType    checksum_type);
+void                  g_checksum_reset              (GChecksum       *checksum);
+GChecksum *           g_checksum_copy               (const GChecksum *checksum);
+void                  g_checksum_free               (GChecksum       *checksum);
+void                  g_checksum_update             (GChecksum       *checksum,
+                                                     const guchar    *data,
+                                                     gssize           length);
+G_CONST_RETURN gchar *g_checksum_get_string         (GChecksum       *checksum);
+void                  g_checksum_get_digest         (GChecksum       *checksum,
+                                                     guint8          *buffer,
+                                                     gsize           *digest_len);
 
-gchar *g_compute_checksum_for_data   (GChecksumType  checksum_type,
-                                      const guchar  *data,
-                                      gsize          length);
-gchar *g_compute_checksum_for_string (GChecksumType  checksum_type,
-                                      const gchar   *str,
-                                      gssize         length);
+gchar                *g_compute_checksum_for_data   (GChecksumType    checksum_type,
+                                                     const guchar    *data,
+                                                     gsize            length);
+gchar                *g_compute_checksum_for_string (GChecksumType    checksum_type,
+                                                     const gchar     *str,
+                                                     gssize           length);
 
 G_END_DECLS
 

data/vendor/local/include/glib-2.0/glib/gcompletion.h

@@ -56,6 +56,8 @@ struct _GCompletion
   GCompletionStrncmpFunc strncmp_func;
 };
 
+#ifndef G_DISABLE_DEPRECATED
+
 GCompletion* g_completion_new           (GCompletionFunc func);
 void         g_completion_add_items     (GCompletion*    cmp,
                                          GList*          items);
@@ -72,6 +74,8 @@ void         g_completion_set_compare   (GCompletion *cmp,
 				         GCompletionStrncmpFunc strncmp_func);
 void         g_completion_free          (GCompletion*    cmp);
 
+#endif
+
 G_END_DECLS
 
 #endif /* __G_COMPLETION_H__ */

data/vendor/local/include/glib-2.0/glib/gconvert.h

@@ -35,7 +35,19 @@
 
 G_BEGIN_DECLS
 
-typedef enum 
+/**
+ * GConvertError:
+ * @G_CONVERT_ERROR_NO_CONVERSION: Conversion between the requested character
+ *     sets is not supported.
+ * @G_CONVERT_ERROR_ILLEGAL_SEQUENCE: Invalid byte sequence in conversion input.
+ * @G_CONVERT_ERROR_FAILED: Conversion failed for some reason.
+ * @G_CONVERT_ERROR_PARTIAL_INPUT: Partial character sequence at end of input.
+ * @G_CONVERT_ERROR_BAD_URI: URI is invalid.
+ * @G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: Pathname is not an absolute path.
+ *
+ * Error codes returned by character set conversion routines.
+ */
+typedef enum
 {
   G_CONVERT_ERROR_NO_CONVERSION,
   G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
@@ -45,10 +57,22 @@ typedef enum
   G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
 } GConvertError;
 
+/**
+ * G_CONVERT_ERROR:
+ *
+ * Error domain for character set conversions. Errors in this domain will
+ * be from the #GConvertError enumeration. See #GError for information on
+ * error domains.
+ */
 #define G_CONVERT_ERROR g_convert_error_quark()
 GQuark g_convert_error_quark (void);
 
-/* Thin wrappers around iconv
+/**
+ * GIconv:
+ *
+ * The <structname>GIConv</structname> struct wraps an
+ * iconv() conversion descriptor. It contains private data
+ * and should only be accessed using the following functions.
  */
 typedef struct _GIConv *GIConv;
 

data/vendor/local/include/glib-2.0/glib/gdatetime.h

@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2009-2010 Christian Hergert <chris@dronelabs.com>
+ * Copyright © 2010 Codethink Limited
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of the
+ * licence, or (at your option) any later version.
+ *
+ * This is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+ * USA.
+ *
+ * Authors: Christian Hergert <chris@dronelabs.com>
+ *          Thiago Santos <thiago.sousa.santos@collabora.co.uk>
+ *          Emmanuele Bassi <ebassi@linux.intel.com>
+ *          Ryan Lortie <desrt@desrt.ca>
+ */
+
+#if defined(G_DISABLE_SINGLE_INCLUDES) && !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
+#error "Only <glib.h> can be included directly."
+#endif
+
+#ifndef __G_DATE_TIME_H__
+#define __G_DATE_TIME_H__
+
+#include <glib/gtimezone.h>
+
+G_BEGIN_DECLS
+
+/**
+ * G_TIME_SPAN_DAY:
+ *
+ * Evaluates to a time span of one day.
+ *
+ * Since: 2.26
+ */
+#define G_TIME_SPAN_DAY                 (G_GINT64_CONSTANT (86400000000))
+
+/**
+ * G_TIME_SPAN_HOUR:
+ *
+ * Evaluates to a time span of one hour.
+ *
+ * Since: 2.26
+ */
+#define G_TIME_SPAN_HOUR                (G_GINT64_CONSTANT (3600000000))
+
+/**
+ * G_TIME_SPAN_MINUTE:
+ *
+ * Evaluates to a time span of one minute.
+ *
+ * Since: 2.26
+ */
+#define G_TIME_SPAN_MINUTE              (G_GINT64_CONSTANT (60000000))
+
+/**
+ * G_TIME_SPAN_SECOND:
+ *
+ * Evaluates to a time span of one second.
+ *
+ * Since: 2.26
+ */
+#define G_TIME_SPAN_SECOND              (G_GINT64_CONSTANT (1000000))
+
+/**
+ * G_TIME_SPAN_MILLISECOND:
+ *
+ * Evaluates to a time span of one millisecond.
+ *
+ * Since: 2.26
+ */
+#define G_TIME_SPAN_MILLISECOND         (G_GINT64_CONSTANT (1000))
+
+/**
+ * GTimeSpan:
+ *
+ * A value representing an interval of time, in microseconds.
+ *
+ * Since: 2.26
+ */
+typedef gint64 GTimeSpan;
+
+/**
+ * GDateTime:
+ *
+ * <structname>GDateTime</structname> is an opaque structure whose members
+ * cannot be accessed directly.
+ *
+ * Since: 2.26
+ */
+typedef struct _GDateTime GDateTime;
+
+void                    g_date_time_unref                               (GDateTime      *datetime);
+GDateTime *             g_date_time_ref                                 (GDateTime      *datetime);
+
+GDateTime *             g_date_time_new_now                             (GTimeZone      *tz);
+GDateTime *             g_date_time_new_now_local                       (void);
+GDateTime *             g_date_time_new_now_utc                         (void);
+
+GDateTime *             g_date_time_new_from_unix_local                 (gint64          t);
+GDateTime *             g_date_time_new_from_unix_utc                   (gint64          t);
+
+GDateTime *             g_date_time_new_from_timeval_local              (const GTimeVal *tv);
+GDateTime *             g_date_time_new_from_timeval_utc                (const GTimeVal *tv);
+
+GDateTime *             g_date_time_new                                 (GTimeZone      *tz,
+                                                                         gint            year,
+                                                                         gint            month,
+                                                                         gint            day,
+                                                                         gint            hour,
+                                                                         gint            minute,
+                                                                         gdouble         seconds);
+GDateTime *             g_date_time_new_local                           (gint            year,
+                                                                         gint            month,
+                                                                         gint            day,
+                                                                         gint            hour,
+                                                                         gint            minute,
+                                                                         gdouble         seconds);
+GDateTime *             g_date_time_new_utc                             (gint            year,
+                                                                         gint            month,
+                                                                         gint            day,
+                                                                         gint            hour,
+                                                                         gint            minute,
+                                                                         gdouble         seconds);
+
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add                                 (GDateTime      *datetime,
+                                                                         GTimeSpan       timespan);
+
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_years                           (GDateTime      *datetime,
+                                                                         gint            years);
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_months                          (GDateTime      *datetime,
+                                                                         gint            months);
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_weeks                           (GDateTime      *datetime,
+                                                                         gint            weeks);
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_days                            (GDateTime      *datetime,
+                                                                         gint            days);
+
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_hours                           (GDateTime      *datetime,
+                                                                         gint            hours);
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_minutes                         (GDateTime      *datetime,
+                                                                         gint            minutes);
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_seconds                         (GDateTime      *datetime,
+                                                                         gdouble         seconds);
+
+G_GNUC_WARN_UNUSED_RESULT
+GDateTime *             g_date_time_add_full                            (GDateTime      *datetime,
+                                                                         gint            years,
+                                                                         gint            months,
+                                                                         gint            days,
+                                                                         gint            hours,
+                                                                         gint            minutes,
+                                                                         gdouble         seconds);
+
+gint                    g_date_time_compare                             (gconstpointer   dt1,
+                                                                         gconstpointer   dt2);
+GTimeSpan               g_date_time_difference                          (GDateTime      *end,
+                                                                         GDateTime      *begin);
+guint                   g_date_time_hash                                (gconstpointer   datetime);
+gboolean                g_date_time_equal                               (gconstpointer   dt1,
+                                                                         gconstpointer   dt2);
+
+void                    g_date_time_get_ymd                             (GDateTime      *datetime,
+                                                                         gint           *year,
+                                                                         gint           *month,
+                                                                         gint           *day);
+
+gint                    g_date_time_get_year                            (GDateTime      *datetime);
+gint                    g_date_time_get_month                           (GDateTime      *datetime);
+gint                    g_date_time_get_day_of_month                    (GDateTime      *datetime);
+
+gint                    g_date_time_get_week_numbering_year             (GDateTime      *datetime);
+gint                    g_date_time_get_week_of_year                    (GDateTime      *datetime);
+gint                    g_date_time_get_day_of_week                     (GDateTime      *datetime);
+
+gint                    g_date_time_get_day_of_year                     (GDateTime      *datetime);
+
+gint                    g_date_time_get_hour                            (GDateTime      *datetime);
+gint                    g_date_time_get_minute                          (GDateTime      *datetime);
+gint                    g_date_time_get_second                          (GDateTime      *datetime);
+gint                    g_date_time_get_microsecond                     (GDateTime      *datetime);
+gdouble                 g_date_time_get_seconds                         (GDateTime      *datetime);
+
+gint64                  g_date_time_to_unix                             (GDateTime      *datetime);
+gboolean                g_date_time_to_timeval                          (GDateTime      *datetime,
+                                                                         GTimeVal       *tv);
+
+GTimeSpan               g_date_time_get_utc_offset                      (GDateTime      *datetime);
+const gchar *           g_date_time_get_timezone_abbreviation           (GDateTime      *datetime);
+gboolean                g_date_time_is_daylight_savings                 (GDateTime      *datetime);
+
+GDateTime *             g_date_time_to_timezone                         (GDateTime      *datetime,
+                                                                         GTimeZone      *tz);
+GDateTime *             g_date_time_to_local                            (GDateTime      *datetime);
+GDateTime *             g_date_time_to_utc                              (GDateTime      *datetime);
+
+gchar *                 g_date_time_format                              (GDateTime      *datetime,
+                                                                         const gchar    *format) G_GNUC_MALLOC;
+
+G_END_DECLS
+
+#endif /* __G_DATE_TIME_H__ */

data/vendor/local/include/glib-2.0/glib/gkeyfile.h

@@ -136,6 +136,22 @@ void      g_key_file_set_integer            (GKeyFile             *key_file,
 					     const gchar          *group_name,
 					     const gchar          *key,
 					     gint                  value);
+gint64    g_key_file_get_int64              (GKeyFile             *key_file,
+					     const gchar          *group_name,
+					     const gchar          *key,
+					     GError              **error);
+void      g_key_file_set_int64              (GKeyFile             *key_file,
+					     const gchar          *group_name,
+					     const gchar          *key,
+					     gint64                value);
+guint64   g_key_file_get_uint64             (GKeyFile             *key_file,
+					     const gchar          *group_name,
+					     const gchar          *key,
+					     GError              **error);
+void      g_key_file_set_uint64             (GKeyFile             *key_file,
+					     const gchar          *group_name,
+					     const gchar          *key,
+					     guint64               value);
 gdouble   g_key_file_get_double             (GKeyFile             *key_file,
                                              const gchar          *group_name,
                                              const gchar          *key,

data/vendor/local/include/glib-2.0/glib/gmacros.h

@@ -107,6 +107,13 @@
 #define G_GNUC_DEPRECATED
 #endif /* __GNUC__ */
 
+#if    __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
+#define G_GNUC_DEPRECATED_FOR(f)                        \
+  __attribute__((deprecated("Use " #f " instead")))
+#else
+#define G_GNUC_DEPRECATED_FOR(f)        G_GNUC_DEPRECATED
+#endif /* __GNUC__ */
+
 #if     __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
 #  define G_GNUC_MAY_ALIAS __attribute__((may_alias))
 #else

data/vendor/local/include/glib-2.0/glib/gmain.h

@@ -8,7 +8,7 @@
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
@@ -30,16 +30,112 @@
 
 G_BEGIN_DECLS
 
-typedef struct _GMainContext	        GMainContext;	/* Opaque */
-typedef struct _GMainLoop	        GMainLoop;	/* Opaque */
-typedef struct _GSource	                GSource;
-typedef struct _GSourceCallbackFuncs	GSourceCallbackFuncs;
-typedef struct _GSourceFuncs	        GSourceFuncs;
+/**
+ * GMainContext:
+ *
+ * The <structname>GMainContext</structname> struct is an opaque data
+ * type representing a set of sources to be handled in a main loop.
+ */
+typedef struct _GMainContext            GMainContext;
+
+/**
+ * GMainLoop:
+ *
+ * The <structname>GMainLoop</structname> struct is an opaque data type
+ * representing the main event loop of a GLib or GTK+ application.
+ */
+typedef struct _GMainLoop               GMainLoop;
+
+/**
+ * GSource:
+ *
+ * The <structname>GSource</structname> struct is an opaque data type
+ * representing an event source.
+ */
+typedef struct _GSource                 GSource;
+
+/**
+ * GSourceCallbackFuncs:
+ * @ref: Called when a reference is added to the callback object
+ * @unref: Called when a reference to the callback object is dropped
+ * @get: Called to extract the callback function and data from the
+ *     callback object.
+
+ * The <structname>GSourceCallbackFuncs</structname> struct contains
+ * functions for managing callback objects.
+ */
+typedef struct _GSourceCallbackFuncs    GSourceCallbackFuncs;
+
+/**
+ * GSourceFuncs:
+ * @prepare: Called before all the file descriptors are polled. If the
+ *     source can determine that it is ready here (without waiting for the
+ *     results of the poll() call) it should return %TRUE. It can also return
+ *     a @timeout_ value which should be the maximum timeout (in milliseconds)
+ *     which should be passed to the poll() call. The actual timeout used will
+ *     be -1 if all sources returned -1, or it will be the minimum of all the
+ *     @timeout_ values returned which were >= 0.
+ * @check: Called after all the file descriptors are polled. The source
+ *     should return %TRUE if it is ready to be dispatched. Note that some
+ *     time may have passed since the previous prepare function was called,
+ *     so the source should be checked again here.
+ * @dispatch: Called to dispatch the event source, after it has returned
+ *     %TRUE in either its @prepare or its @check function. The @dispatch
+ *     function is passed in a callback function and data. The callback
+ *     function may be %NULL if the source was never connected to a callback
+ *     using g_source_set_callback(). The @dispatch function should call the
+ *     callback function with @user_data and whatever additional parameters
+ *     are needed for this type of event source.
+ * @finalize: Called when the source is finalized.
+ * @closure_callback:
+ * @closure_marshal:
+ *
+ * The <structname>GSourceFuncs</structname> struct contains a table of
+ * functions used to handle event sources in a generic manner.
+ *
+ * For idle sources, the prepare and check functions always return %TRUE
+ * to indicate that the source is always ready to be processed. The prepare
+ * function also returns a timeout value of 0 to ensure that the poll() call
+ * doesn't block (since that would be time wasted which could have been spent
+ * running the idle function).
+ *
+ * For timeout sources, the prepare and check functions both return %TRUE
+ * if the timeout interval has expired. The prepare function also returns
+ * a timeout value to ensure that the poll() call doesn't block too long
+ * and miss the next timeout.
+ *
+ * For file descriptor sources, the prepare function typically returns %FALSE,
+ * since it must wait until poll() has been called before it knows whether
+ * any events need to be processed. It sets the returned timeout to -1 to
+ * indicate that it doesn't mind how long the poll() call blocks. In the
+ * check function, it tests the results of the poll() call to see if the
+ * required condition has been met, and returns %TRUE if so.
+ */
+typedef struct _GSourceFuncs            GSourceFuncs;
+
+/**
+ * GPid:
+ *
+ * A type which is used to hold a process identification.
+ *
+ * On UNIX, processes are identified by a process id (an integer),
+ * while Windows uses process handles (which are pointers).
+ */
 
 typedef gboolean (*GSourceFunc)       (gpointer data);
+
+/**
+ * GChildWatchFunc:
+ * @pid: the process id of the child process
+ * @status: Status information about the child process,
+ *     see waitpid(2) for more information about this field
+ * @data: user data passed to g_child_watch_add()
+ *
+ * The type of functions to be called when a child exists.
+ */
 typedef void     (*GChildWatchFunc)   (GPid     pid,
-				       gint     status,
-				       gpointer data);
+                                       gint     status,
+                                       gpointer data);
 struct _GSource
 {
   /*< private >*/
@@ -60,7 +156,7 @@ struct _GSource
   GSource *prev;
   GSource *next;
 
-  gpointer reserved1;
+  char    *name;
   gpointer reserved2;
 };
 
@@ -69,9 +165,9 @@ struct _GSourceCallbackFuncs
   void (*ref)   (gpointer     cb_data);
   void (*unref) (gpointer     cb_data);
   void (*get)   (gpointer     cb_data,
-		 GSource     *source, 
-		 GSourceFunc *func,
-		 gpointer    *data);
+                 GSource     *source, 
+                 GSourceFunc *func,
+                 gpointer    *data);
 };
 
 typedef void (*GSourceDummyMarshal) (void);
@@ -79,25 +175,70 @@ typedef void (*GSourceDummyMarshal) (void);
 struct _GSourceFuncs
 {
   gboolean (*prepare)  (GSource    *source,
-			gint       *timeout_);
+                        gint       *timeout_);
   gboolean (*check)    (GSource    *source);
   gboolean (*dispatch) (GSource    *source,
-			GSourceFunc callback,
-			gpointer    user_data);
+                        GSourceFunc callback,
+                        gpointer    user_data);
   void     (*finalize) (GSource    *source); /* Can be NULL */
 
   /* For use by g_source_set_closure */
-  GSourceFunc     closure_callback;	   
+  GSourceFunc     closure_callback;        
   GSourceDummyMarshal closure_marshal; /* Really is of type GClosureMarshal */
 };
 
 /* Standard priorities */
 
+/**
+ * G_PRIORITY_HIGH:
+ *
+ * Use this for high priority event sources.
+ *
+ * It is not used within GLib or GTK+.
+ */
 #define G_PRIORITY_HIGH            -100
+
+/**
+ * G_PRIORITY_DEFAULT:
+ *
+ * Use this for default priority event sources.
+ *
+ * In GLib this priority is used when adding timeout functions
+ * with g_timeout_add(). In GDK this priority is used for events
+ * from the X server.
+ */
 #define G_PRIORITY_DEFAULT          0
+
+/**
+ * G_PRIORITY_HIGH_IDLE:
+ *
+ * Use this for high priority idle functions.
+ *
+ * GTK+ uses #G_PRIORITY_HIGH_IDLE + 10 for resizing operations,
+ * and #G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is
+ * done to ensure that any pending resizes are processed before any
+ * pending redraws, so that widgets are not redrawn twice unnecessarily.)
+ */
 #define G_PRIORITY_HIGH_IDLE        100
+
+/**
+ * G_PRIORITY_DEFAULT_IDLE:
+ *
+ * Use this for default priority idle functions.
+ *
+ * In GLib this priority is used when adding idle functions with
+ * g_idle_add().
+ */
 #define G_PRIORITY_DEFAULT_IDLE     200
-#define G_PRIORITY_LOW	            300
+
+/**
+ * G_PRIORITY_LOW:
+ *
+ * Use this for very low priority background tasks.
+ *
+ * It is not used within GLib or GTK+.
+ */
+#define G_PRIORITY_LOW              300
 
 /* GMainContext: */
 
@@ -107,18 +248,18 @@ void          g_main_context_unref     (GMainContext *context);
 GMainContext *g_main_context_default   (void);
 
 gboolean      g_main_context_iteration (GMainContext *context,
-					gboolean      may_block);
+                                        gboolean      may_block);
 gboolean      g_main_context_pending   (GMainContext *context);
 
 /* For implementation of legacy interfaces
  */
 GSource      *g_main_context_find_source_by_id              (GMainContext *context,
-							     guint         source_id);
+                                                             guint         source_id);
 GSource      *g_main_context_find_source_by_user_data       (GMainContext *context,
-							     gpointer      user_data);
+                                                             gpointer      user_data);
 GSource      *g_main_context_find_source_by_funcs_user_data (GMainContext *context,
- 							     GSourceFuncs *funcs,
-							     gpointer      user_data);
+                                                             GSourceFuncs *funcs,
+                                                             gpointer      user_data);
 
 /* Low level functions for implementing custom main loops.
  */
@@ -127,33 +268,33 @@ gboolean g_main_context_acquire (GMainContext *context);
 void     g_main_context_release (GMainContext *context);
 gboolean g_main_context_is_owner (GMainContext *context);
 gboolean g_main_context_wait    (GMainContext *context,
-				 GCond        *cond,
-				 GMutex       *mutex);
+                                 GCond        *cond,
+                                 GMutex       *mutex);
 
 gboolean g_main_context_prepare  (GMainContext *context,
-				  gint         *priority);
+                                  gint         *priority);
 gint     g_main_context_query    (GMainContext *context,
-				  gint          max_priority,
-				  gint         *timeout_,
-				  GPollFD      *fds,
-				  gint          n_fds);
+                                  gint          max_priority,
+                                  gint         *timeout_,
+                                  GPollFD      *fds,
+                                  gint          n_fds);
 gint     g_main_context_check    (GMainContext *context,
-				  gint          max_priority,
-				  GPollFD      *fds,
-				  gint          n_fds);
+                                  gint          max_priority,
+                                  GPollFD      *fds,
+                                  gint          n_fds);
 void     g_main_context_dispatch (GMainContext *context);
 
 void     g_main_context_set_poll_func (GMainContext *context,
-				       GPollFunc     func);
+                                       GPollFunc     func);
 GPollFunc g_main_context_get_poll_func (GMainContext *context);
 
 /* Low level functions for use by source implementations
  */
 void     g_main_context_add_poll    (GMainContext *context,
-				     GPollFD      *fd,
-				     gint          priority);
+                                     GPollFD      *fd,
+                                     gint          priority);
 void     g_main_context_remove_poll (GMainContext *context,
-				     GPollFD      *fd);
+                                     GPollFD      *fd);
 
 gint     g_main_depth               (void);
 GSource *g_main_current_source      (void);
@@ -167,7 +308,7 @@ GMainContext *g_main_context_get_thread_default  (void);
 /* GMainLoop: */
 
 GMainLoop *g_main_loop_new        (GMainContext *context,
-			    	   gboolean      is_running);
+                                   gboolean      is_running);
 void       g_main_loop_run        (GMainLoop    *loop);
 void       g_main_loop_quit       (GMainLoop    *loop);
 GMainLoop *g_main_loop_ref        (GMainLoop    *loop);
@@ -178,45 +319,52 @@ GMainContext *g_main_loop_get_context (GMainLoop    *loop);
 /* GSource: */
 
 GSource *g_source_new             (GSourceFuncs   *source_funcs,
-				   guint           struct_size);
+                                   guint           struct_size);
 GSource *g_source_ref             (GSource        *source);
 void     g_source_unref           (GSource        *source);
 
 guint    g_source_attach          (GSource        *source,
-				   GMainContext   *context);
+                                   GMainContext   *context);
 void     g_source_destroy         (GSource        *source);
 
 void     g_source_set_priority    (GSource        *source,
-				   gint            priority);
+                                   gint            priority);
 gint     g_source_get_priority    (GSource        *source);
 void     g_source_set_can_recurse (GSource        *source,
-				   gboolean        can_recurse);
+                                   gboolean        can_recurse);
 gboolean g_source_get_can_recurse (GSource        *source);
 guint    g_source_get_id          (GSource        *source);
 
 GMainContext *g_source_get_context (GSource       *source);
 
 void     g_source_set_callback    (GSource        *source,
-				   GSourceFunc     func,
-				   gpointer        data,
-				   GDestroyNotify  notify);
+                                   GSourceFunc     func,
+                                   gpointer        data,
+                                   GDestroyNotify  notify);
 
 void     g_source_set_funcs       (GSource        *source,
                                    GSourceFuncs   *funcs);
 gboolean g_source_is_destroyed    (GSource        *source);
 
+void                 g_source_set_name       (GSource        *source,
+                                              const char     *name);
+G_CONST_RETURN char* g_source_get_name       (GSource        *source);
+void                 g_source_set_name_by_id (guint           tag,
+                                              const char     *name);
+
+
 /* Used to implement g_source_connect_closure and internally*/
 void g_source_set_callback_indirect (GSource              *source,
-				     gpointer              callback_data,
-				     GSourceCallbackFuncs *callback_funcs);
+                                     gpointer              callback_data,
+                                     GSourceCallbackFuncs *callback_funcs);
 
 void     g_source_add_poll         (GSource        *source,
-				    GPollFD        *fd);
+                                    GPollFD        *fd);
 void     g_source_remove_poll      (GSource        *source,
-				    GPollFD        *fd);
+                                    GPollFD        *fd);
 
 void     g_source_get_current_time (GSource        *source,
-				    GTimeVal       *timeval);
+                                    GTimeVal       *timeval);
 
  /* void g_source_connect_closure (GSource        *source,
                                   GClosure       *closure);
@@ -231,27 +379,106 @@ GSource *g_timeout_source_new_seconds (guint interval);
 
 /* Miscellaneous functions
  */
-void g_get_current_time		        (GTimeVal	*result);
+void g_get_current_time                 (GTimeVal       *result);
 
 /* ============== Compat main loop stuff ================== */
 
 #ifndef G_DISABLE_DEPRECATED
 
-/* Legacy names for GMainLoop functions
+/**
+ * g_main_new:
+ * @is_running: set to %TRUE to indicate that the loop is running. This
+ *     is not very important since calling g_main_run() will set this
+ *     to %TRUE anyway.
+ *
+ * Creates a new #GMainLoop for th default main context.
+ *
+ * Returns: a new #GMainLoop
+ *
+ * Deprecated: 2.2: Use g_main_loop_new() instead
+ */
+#define         g_main_new(is_running)  g_main_loop_new (NULL, is_running)
+
+/**
+ * g_main_run:
+ * @loop: a #GMainLoop
+ *
+ * Runs a main loop until it stops running.
+ *
+ * Deprecated: 2.2: Use g_main_loop_run() instead
  */
-#define 	g_main_new(is_running)	g_main_loop_new (NULL, is_running);
 #define         g_main_run(loop)        g_main_loop_run(loop)
-#define         g_main_quit(loop)       g_main_loop_quit(loop)
-#define         g_main_destroy(loop)    g_main_loop_unref(loop)
-#define         g_main_is_running(loop) g_main_loop_is_running(loop)
 
-/* Functions to manipulate the default main loop
+/**
+ * g_main_quit:
+ * @loop: a #GMainLoop
+ *
+ * Stops the #GMainLoop.
+ * If g_main_run() was called to run the #GMainLoop, it will now return.
+ *
+ * Deprecated: 2.2: Use g_main_loop_quit() instead
+ */
+#define g_main_quit(loop)       g_main_loop_quit(loop)
+
+/**
+ * g_main_destroy:
+ * @loop: a #GMainLoop
+ *
+ * Frees the memory allocated for the #GMainLoop.
+ *
+ * Deprecated: 2.2: Use g_main_loop_unref() instead
+ */
+#define g_main_destroy(loop)    g_main_loop_unref(loop)
+
+/**
+ * g_main_is_running:
+ * @loop: a #GMainLoop
+ *
+ * Checks if the main loop is running.
+ *
+ * Returns: %TRUE if the main loop is running
+ *
+ * Deprecated: 2.2: Use g_main_loop_is_running() instead
+ */
+#define g_main_is_running(loop) g_main_loop_is_running(loop)
+
+/**
+ * g_main_iteration:
+ * @may_block: set to %TRUE if it should block (i.e. wait) until an event
+ *     source becomes ready. It will return after an event source has been
+ *     processed. If set to %FALSE it will return immediately if no event
+ *     source is ready to be processed.
+ *
+ * Runs a single iteration for the default #GMainContext.
+ *
+ * Returns: %TRUE if more events are pending.
+ *
+ * Deprecated: 2.2: Use g_main_context_iteration() instead.
  */
+#define g_main_iteration(may_block) g_main_context_iteration (NULL, may_block)
 
-#define	g_main_iteration(may_block) g_main_context_iteration      (NULL, may_block)
-#define g_main_pending()            g_main_context_pending        (NULL)
+/**
+ * g_main_pending:
+ *
+ * Checks if any events are pending for the default #GMainContext
+ * (i.e. ready to be processed).
+ *
+ * Returns: %TRUE if any events are pending.
+ *
+ * Deprected: 2.2: Use g_main_context_pending() instead.
+ */
+#define g_main_pending()            g_main_context_pending (NULL)
 
-#define g_main_set_poll_func(func)   g_main_context_set_poll_func (NULL, func)
+/**
+ * g_main_set_poll_func:
+ * @func: the function to call to poll all file descriptors
+ *
+ * Sets the function to use for the handle polling of file descriptors
+ * for the default main context.
+ *
+ * Deprecated: 2.2: Use g_main_context_set_poll_func() again
+ */
+#define g_main_set_poll_func(func)  g_main_context_set_poll_func (NULL, func)
 
 #endif /* G_DISABLE_DEPRECATED */
 
@@ -259,39 +486,39 @@ void g_get_current_time		        (GTimeVal	*result);
 gboolean g_source_remove                     (guint          tag);
 gboolean g_source_remove_by_user_data        (gpointer       user_data);
 gboolean g_source_remove_by_funcs_user_data  (GSourceFuncs  *funcs,
-					      gpointer       user_data);
+                                              gpointer       user_data);
 
 /* Idles, child watchers and timeouts */
 guint    g_timeout_add_full         (gint            priority,
-				     guint           interval,
-				     GSourceFunc     function,
-				     gpointer        data,
-				     GDestroyNotify  notify);
+                                     guint           interval,
+                                     GSourceFunc     function,
+                                     gpointer        data,
+                                     GDestroyNotify  notify);
 guint    g_timeout_add              (guint           interval,
-				     GSourceFunc     function,
-				     gpointer        data);
+                                     GSourceFunc     function,
+                                     gpointer        data);
 guint    g_timeout_add_seconds_full (gint            priority,
                                      guint           interval,
                                      GSourceFunc     function,
                                      gpointer        data,
                                      GDestroyNotify  notify);
 guint    g_timeout_add_seconds      (guint           interval,
-				     GSourceFunc     function,
-				     gpointer        data);
+                                     GSourceFunc     function,
+                                     gpointer        data);
 guint    g_child_watch_add_full     (gint            priority,
-				     GPid            pid,
-				     GChildWatchFunc function,
-				     gpointer        data,
-				     GDestroyNotify  notify);
+                                     GPid            pid,
+                                     GChildWatchFunc function,
+                                     gpointer        data,
+                                     GDestroyNotify  notify);
 guint    g_child_watch_add          (GPid            pid,
-				     GChildWatchFunc function,
-				     gpointer        data);
+                                     GChildWatchFunc function,
+                                     gpointer        data);
 guint    g_idle_add                 (GSourceFunc     function,
-				     gpointer        data);
+                                     gpointer        data);
 guint    g_idle_add_full            (gint            priority,
-				     GSourceFunc     function,
-				     gpointer        data,
-				     GDestroyNotify  notify);
+                                     GSourceFunc     function,
+                                     gpointer        data,
+                                     GDestroyNotify  notify);
 gboolean g_idle_remove_by_data      (gpointer        data);
 
 /* Hook for GClosure / GSource integration. Don't touch */