Reindent

1 files changed, 364 insertions, 358 deletions

diff --git a/gdk-pixbuf/gdk-pixbuf-loader.c b/gdk-pixbuf/gdk-pixbuf-loader.c
index 0ef899739d..070ade1b12 100644
--- a/gdk-pixbuf/gdk-pixbuf-loader.c
+++ b/gdk-pixbuf/gdk-pixbuf-loader.c
@@ -1,3 +1,4 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
 /* GdkPixbuf library - Progressive loader object
  *
  * Copyright (C) 1999 The Free Software Foundation
@@ -32,11 +33,11 @@
 #include "gdk-pixbuf-marshal.h"
 
 enum {
-  SIZE_PREPARED,
-  AREA_PREPARED,
-  AREA_UPDATED,
-  CLOSED,
-  LAST_SIGNAL
+        SIZE_PREPARED,
+        AREA_PREPARED,
+        AREA_UPDATED,
+        CLOSED,
+        LAST_SIGNAL
 };
 
 
@@ -54,16 +55,16 @@ static guint    pixbuf_loader_signals[LAST_SIGNAL] = { 0 };
 
 typedef struct
 {
-  GdkPixbufAnimation *animation;
-  gboolean closed;
-  guchar header_buf[LOADER_HEADER_SIZE];
-  gint header_buf_offset;
-  GdkPixbufModule *image_module;
-  gpointer context;
-  gint width;
-  gint height;
-  gboolean size_fixed;
-  gboolean needs_scale;
+        GdkPixbufAnimation *animation;
+        gboolean closed;
+        guchar header_buf[LOADER_HEADER_SIZE];
+        gint header_buf_offset;
+        GdkPixbufModule *image_module;
+        gpointer context;
+        gint width;
+        gint height;
+        gboolean size_fixed;
+        gboolean needs_scale;
 } GdkPixbufLoaderPrivate;
 
 
@@ -79,112 +80,112 @@ typedef struct
 GType
 gdk_pixbuf_loader_get_type (void)
 {
-  static GType loader_type = 0;
-  
-  if (!loader_type)
-    {
-      static const GTypeInfo loader_info = {
-        sizeof (GdkPixbufLoaderClass),
-        (GBaseInitFunc) NULL,
-        (GBaseFinalizeFunc) NULL,
-        (GClassInitFunc) gdk_pixbuf_loader_class_init,
-        NULL,           /* class_finalize */
-        NULL,           /* class_data */
-        sizeof (GdkPixbufLoader),
-        0,              /* n_preallocs */
-        (GInstanceInitFunc) gdk_pixbuf_loader_init
-      };
+        static GType loader_type = 0;
+  
+        if (!loader_type)
+                {
+                        static const GTypeInfo loader_info = {
+                                sizeof (GdkPixbufLoaderClass),
+                                (GBaseInitFunc) NULL,
+                                (GBaseFinalizeFunc) NULL,
+                                (GClassInitFunc) gdk_pixbuf_loader_class_init,
+                                NULL,           /* class_finalize */
+                                NULL,           /* class_data */
+                                sizeof (GdkPixbufLoader),
+                                0,              /* n_preallocs */
+                                (GInstanceInitFunc) gdk_pixbuf_loader_init
+                        };
       
-      loader_type = g_type_register_static (G_TYPE_OBJECT,
-                                            "GdkPixbufLoader",
-                                            &loader_info,
-                                            0);
-    }
+                        loader_type = g_type_register_static (G_TYPE_OBJECT,
+                                                              "GdkPixbufLoader",
+                                                              &loader_info,
+                                                              0);
+                }
   
-  return loader_type;
+        return loader_type;
 }
 
 static void
 gdk_pixbuf_loader_class_init (GdkPixbufLoaderClass *class)
 {
-  GObjectClass *object_class;
-  
-  object_class = (GObjectClass *) class;
-  
-  parent_class = g_type_class_peek_parent (class);
-  
-  object_class->finalize = gdk_pixbuf_loader_finalize;
-
-  pixbuf_loader_signals[SIZE_PREPARED] =
-    g_signal_new ("size_prepared",
-                  G_TYPE_FROM_CLASS (object_class),
-                  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GdkPixbufLoaderClass, size_prepared),
-                  NULL, NULL,
-                  gdk_pixbuf_marshal_VOID__INT_INT,
-                  G_TYPE_NONE, 2, 
-		  G_TYPE_INT,
-		  G_TYPE_INT);
-  
-  pixbuf_loader_signals[AREA_PREPARED] =
-    g_signal_new ("area_prepared",
-                  G_TYPE_FROM_CLASS (object_class),
-                  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_prepared),
-                  NULL, NULL,
-                  gdk_pixbuf_marshal_VOID__VOID,
-                  G_TYPE_NONE, 0);
-  
-  pixbuf_loader_signals[AREA_UPDATED] =
-    g_signal_new ("area_updated",
-                  G_TYPE_FROM_CLASS (object_class),
-                  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_updated),
-                  NULL, NULL,
-                  gdk_pixbuf_marshal_VOID__INT_INT_INT_INT,
-                  G_TYPE_NONE, 4,
-                  G_TYPE_INT,
-                  G_TYPE_INT,
-                  G_TYPE_INT,
-                  G_TYPE_INT);
-  
-  pixbuf_loader_signals[CLOSED] =
-    g_signal_new ("closed",
-                  G_TYPE_FROM_CLASS (object_class),
-                  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GdkPixbufLoaderClass, closed),
-                  NULL, NULL,
-                  gdk_pixbuf_marshal_VOID__VOID,
-                  G_TYPE_NONE, 0);
+        GObjectClass *object_class;
+  
+        object_class = (GObjectClass *) class;
+  
+        parent_class = g_type_class_peek_parent (class);
+  
+        object_class->finalize = gdk_pixbuf_loader_finalize;
+
+        pixbuf_loader_signals[SIZE_PREPARED] =
+                g_signal_new ("size_prepared",
+                              G_TYPE_FROM_CLASS (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GdkPixbufLoaderClass, size_prepared),
+                              NULL, NULL,
+                              gdk_pixbuf_marshal_VOID__INT_INT,
+                              G_TYPE_NONE, 2, 
+                              G_TYPE_INT,
+                              G_TYPE_INT);
+  
+        pixbuf_loader_signals[AREA_PREPARED] =
+                g_signal_new ("area_prepared",
+                              G_TYPE_FROM_CLASS (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_prepared),
+                              NULL, NULL,
+                              gdk_pixbuf_marshal_VOID__VOID,
+                              G_TYPE_NONE, 0);
+  
+        pixbuf_loader_signals[AREA_UPDATED] =
+                g_signal_new ("area_updated",
+                              G_TYPE_FROM_CLASS (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_updated),
+                              NULL, NULL,
+                              gdk_pixbuf_marshal_VOID__INT_INT_INT_INT,
+                              G_TYPE_NONE, 4,
+                              G_TYPE_INT,
+                              G_TYPE_INT,
+                              G_TYPE_INT,
+                              G_TYPE_INT);
+  
+        pixbuf_loader_signals[CLOSED] =
+                g_signal_new ("closed",
+                              G_TYPE_FROM_CLASS (object_class),
+                              G_SIGNAL_RUN_LAST,
+                              G_STRUCT_OFFSET (GdkPixbufLoaderClass, closed),
+                              NULL, NULL,
+                              gdk_pixbuf_marshal_VOID__VOID,
+                              G_TYPE_NONE, 0);
 }
 
 static void
 gdk_pixbuf_loader_init (GdkPixbufLoader *loader)
 {
-  GdkPixbufLoaderPrivate *priv;
+        GdkPixbufLoaderPrivate *priv;
   
-  priv = g_new0 (GdkPixbufLoaderPrivate, 1);
-  loader->priv = priv;
+        priv = g_new0 (GdkPixbufLoaderPrivate, 1);
+        loader->priv = priv;
 }
 
 static void
 gdk_pixbuf_loader_finalize (GObject *object)
 {
-  GdkPixbufLoader *loader;
-  GdkPixbufLoaderPrivate *priv = NULL;
+        GdkPixbufLoader *loader;
+        GdkPixbufLoaderPrivate *priv = NULL;
   
-  loader = GDK_PIXBUF_LOADER (object);
-  priv = loader->priv;
+        loader = GDK_PIXBUF_LOADER (object);
+        priv = loader->priv;
 
-  if (!priv->closed)
-    g_warning ("GdkPixbufLoader finalized without calling gdk_pixbuf_loader_close() - this is not allowed. You must explicitly end the data stream to the loader before dropping the last reference.");
+        if (!priv->closed)
+                g_warning ("GdkPixbufLoader finalized without calling gdk_pixbuf_loader_close() - this is not allowed. You must explicitly end the data stream to the loader before dropping the last reference.");
   
-  if (priv->animation)
-    g_object_unref (priv->animation);
+        if (priv->animation)
+                g_object_unref (priv->animation);
   
-  g_free (priv);
+        g_free (priv);
   
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+        G_OBJECT_CLASS (parent_class)->finalize (object);
 }
 
 /**
@@ -206,31 +207,33 @@ gdk_pixbuf_loader_set_size (GdkPixbufLoader *loader,
 			    gint             width,
 			    gint             height)
 {
-  GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
-  g_return_if_fail (width > 0 && height > 0);
-
-  if (!priv->size_fixed) {
-    priv->width = width;
-    priv->height = height;
-  }
+        GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
+        g_return_if_fail (width > 0 && height > 0);
+
+        if (!priv->size_fixed) 
+                {
+                        priv->width = width;
+                        priv->height = height;
+                }
 }
 
 static void
 gdk_pixbuf_loader_size_func (gint *width, gint *height, gpointer loader)
 {
-  GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
+        GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
 
-  /* allow calling gdk_pixbuf_loader_set_size() before the signal */
-  if (priv->width == 0 && priv->height == 0) {
-    priv->width = *width;
-    priv->height = *height;
-  }
+        /* allow calling gdk_pixbuf_loader_set_size() before the signal */
+        if (priv->width == 0 && priv->height == 0) 
+                {
+                        priv->width = *width;
+                        priv->height = *height;
+                }
 
-  g_signal_emit (loader, pixbuf_loader_signals[SIZE_PREPARED], 0, *width, *height);
-  priv->size_fixed = TRUE;
+        g_signal_emit (loader, pixbuf_loader_signals[SIZE_PREPARED], 0, *width, *height);
+        priv->size_fixed = TRUE;
 
-  *width = priv->width;
-  *height = priv->height;
+        *width = priv->width;
+        *height = priv->height;
 }
 
 static void
@@ -238,32 +241,33 @@ gdk_pixbuf_loader_prepare (GdkPixbuf          *pixbuf,
                            GdkPixbufAnimation *anim,
 			   gpointer            loader)
 {
-  GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
-  g_return_if_fail (pixbuf != NULL);
-
-  if (!priv->size_fixed) {
-    /* Defend against lazy loaders which don't call size_func */
-    gint width = gdk_pixbuf_get_width (pixbuf);
-    gint height = gdk_pixbuf_get_height (pixbuf);
-
-    gdk_pixbuf_loader_size_func (&width, &height, loader);
-  }
-
-  priv->needs_scale = FALSE;
-  if (priv->width > 0 && priv->height > 0 &&
-      (priv->width != gdk_pixbuf_get_width (pixbuf) ||
-       priv->height != gdk_pixbuf_get_height (pixbuf)))
-    priv->needs_scale = TRUE;
-
-  if (anim)
-    g_object_ref (anim);
-  else
-    anim = gdk_pixbuf_non_anim_new (pixbuf);
-  
-  priv->animation = anim;
-  
-  if (!priv->needs_scale)
-    g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
+        GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
+        g_return_if_fail (pixbuf != NULL);
+
+        if (!priv->size_fixed) 
+                {
+                        /* Defend against lazy loaders which don't call size_func */
+                        gint width = gdk_pixbuf_get_width (pixbuf);
+                        gint height = gdk_pixbuf_get_height (pixbuf);
+                        
+                        gdk_pixbuf_loader_size_func (&width, &height, loader);
+                }
+
+        priv->needs_scale = FALSE;
+        if (priv->width > 0 && priv->height > 0 &&
+            (priv->width != gdk_pixbuf_get_width (pixbuf) ||
+             priv->height != gdk_pixbuf_get_height (pixbuf)))
+                priv->needs_scale = TRUE;
+
+        if (anim)
+                g_object_ref (anim);
+        else
+                anim = gdk_pixbuf_non_anim_new (pixbuf);
+  
+        priv->animation = anim;
+  
+        if (!priv->needs_scale)
+                g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
 }
 
 static void
@@ -274,16 +278,16 @@ gdk_pixbuf_loader_update (GdkPixbuf *pixbuf,
 			  gint       height,
 			  gpointer   loader)
 {
-  GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
-  
-  if (!priv->needs_scale)
-    g_signal_emit (loader,
-		   pixbuf_loader_signals[AREA_UPDATED],
-		   0,
-		   x, y,
-		   /* sanity check in here.  Defend against an errant loader */
-		   MIN (width, gdk_pixbuf_animation_get_width (priv->animation)),
-		   MIN (height, gdk_pixbuf_animation_get_height (priv->animation)));
+        GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
+  
+        if (!priv->needs_scale)
+                g_signal_emit (loader,
+                               pixbuf_loader_signals[AREA_UPDATED],
+                               0,
+                               x, y,
+                               /* sanity check in here.  Defend against an errant loader */
+                               MIN (width, gdk_pixbuf_animation_get_width (priv->animation)),
+                               MIN (height, gdk_pixbuf_animation_get_height (priv->animation)));
 }
 
 static gint
@@ -291,77 +295,77 @@ gdk_pixbuf_loader_load_module (GdkPixbufLoader *loader,
                                const char      *image_type,
                                GError         **error)
 {
-  GdkPixbufLoaderPrivate *priv = loader->priv;
-
-  if (image_type)
-    {
-      priv->image_module = _gdk_pixbuf_get_named_module (image_type,
-                                                         error);
-    }
-  else
-    {
-      priv->image_module = _gdk_pixbuf_get_module (priv->header_buf,
-                                                   priv->header_buf_offset,
-                                                   NULL,
-                                                   error);
-    }
-  
-  if (priv->image_module == NULL)
-    return 0;
-  
-  if (priv->image_module->module == NULL)
-    if (!_gdk_pixbuf_load_module (priv->image_module, error))
-      return 0;
-  
-  if (priv->image_module->module == NULL)
-    return 0;
-  
-  if ((priv->image_module->begin_load == NULL) ||
-      (priv->image_module->stop_load == NULL) ||
-      (priv->image_module->load_increment == NULL))
-    {
-      g_set_error (error,
-                   GDK_PIXBUF_ERROR,
-                   GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
-                   _("Incremental loading of image type '%s' is not supported"),
-                   priv->image_module->module_name);
-
-      return 0;
-    }
-
-    priv->context = priv->image_module->begin_load (gdk_pixbuf_loader_size_func,
-						    gdk_pixbuf_loader_prepare,
-						    gdk_pixbuf_loader_update,
-						    loader,
-						    error);
-  
-  if (priv->context == NULL)
-    {
-      /* Defense against broken loaders; DO NOT take this as a GError
-       * example
-       */
-      if (error && *error == NULL)
-        {
-          g_warning ("Bug! loader '%s' didn't set an error on failure",
-                     priv->image_module->module_name);
-          g_set_error (error,
-                       GDK_PIXBUF_ERROR,
-                       GDK_PIXBUF_ERROR_FAILED,
-                       _("Internal error: Image loader module '%s'"
-                         " failed to begin loading an image, but didn't"
-                         " give a reason for the failure"),
-                       priv->image_module->module_name);
-
-        }
+        GdkPixbufLoaderPrivate *priv = loader->priv;
+
+        if (image_type)
+                {
+                        priv->image_module = _gdk_pixbuf_get_named_module (image_type,
+                                                                           error);
+                }
+        else
+                {
+                        priv->image_module = _gdk_pixbuf_get_module (priv->header_buf,
+                                                                     priv->header_buf_offset,
+                                                                     NULL,
+                                                                     error);
+                }
+  
+        if (priv->image_module == NULL)
+                return 0;
+  
+        if (priv->image_module->module == NULL)
+                if (!_gdk_pixbuf_load_module (priv->image_module, error))
+                        return 0;
+  
+        if (priv->image_module->module == NULL)
+                return 0;
+  
+        if ((priv->image_module->begin_load == NULL) ||
+            (priv->image_module->stop_load == NULL) ||
+            (priv->image_module->load_increment == NULL))
+                {
+                        g_set_error (error,
+                                     GDK_PIXBUF_ERROR,
+                                     GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
+                                     _("Incremental loading of image type '%s' is not supported"),
+                                     priv->image_module->module_name);
+
+                        return 0;
+                }
+
+        priv->context = priv->image_module->begin_load (gdk_pixbuf_loader_size_func,
+                                                        gdk_pixbuf_loader_prepare,
+                                                        gdk_pixbuf_loader_update,
+                                                        loader,
+                                                        error);
+  
+        if (priv->context == NULL)
+                {
+                        /* Defense against broken loaders; DO NOT take this as a GError
+                         * example
+                         */
+                        if (error && *error == NULL)
+                                {
+                                        g_warning ("Bug! loader '%s' didn't set an error on failure",
+                                                   priv->image_module->module_name);
+                                        g_set_error (error,
+                                                     GDK_PIXBUF_ERROR,
+                                                     GDK_PIXBUF_ERROR_FAILED,
+                                                     _("Internal error: Image loader module '%s'"
+                                                       " failed to begin loading an image, but didn't"
+                                                       " give a reason for the failure"),
+                                                     priv->image_module->module_name);
+
+                                }
       
-      return 0;
-    }
+                        return 0;
+                }
   
-  if (priv->header_buf_offset
-      && priv->image_module->load_increment (priv->context, priv->header_buf, priv->header_buf_offset, error))
-    return priv->header_buf_offset;
+        if (priv->header_buf_offset
+            && priv->image_module->load_increment (priv->context, priv->header_buf, priv->header_buf_offset, error))
+                return priv->header_buf_offset;
   
-  return 0;
+        return 0;
 }
 
 static int
@@ -370,21 +374,21 @@ gdk_pixbuf_loader_eat_header_write (GdkPixbufLoader *loader,
 				    gsize            count,
                                     GError         **error)
 {
-  gint n_bytes;
-  GdkPixbufLoaderPrivate *priv = loader->priv;
+        gint n_bytes;
+        GdkPixbufLoaderPrivate *priv = loader->priv;
   
-  n_bytes = MIN(LOADER_HEADER_SIZE - priv->header_buf_offset, count);
-  memcpy (priv->header_buf + priv->header_buf_offset, buf, n_bytes);
+        n_bytes = MIN(LOADER_HEADER_SIZE - priv->header_buf_offset, count);
+        memcpy (priv->header_buf + priv->header_buf_offset, buf, n_bytes);
   
-  priv->header_buf_offset += n_bytes;
+        priv->header_buf_offset += n_bytes;
   
-  if (priv->header_buf_offset >= LOADER_HEADER_SIZE)
-    {
-      if (gdk_pixbuf_loader_load_module (loader, NULL, error) == 0)
-	return 0;
-    }
+        if (priv->header_buf_offset >= LOADER_HEADER_SIZE)
+                {
+                        if (gdk_pixbuf_loader_load_module (loader, NULL, error) == 0)
+                                return 0;
+                }
   
-  return n_bytes;
+        return n_bytes;
 }
 
 /**
@@ -410,54 +414,54 @@ gdk_pixbuf_loader_write (GdkPixbufLoader *loader,
 			 gsize            count,
                          GError         **error)
 {
-  GdkPixbufLoaderPrivate *priv;
+        GdkPixbufLoaderPrivate *priv;
   
-  g_return_val_if_fail (loader != NULL, FALSE);
-  g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), FALSE);
+        g_return_val_if_fail (loader != NULL, FALSE);
+        g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), FALSE);
   
-  g_return_val_if_fail (buf != NULL, FALSE);
-  g_return_val_if_fail (count >= 0, FALSE);
+        g_return_val_if_fail (buf != NULL, FALSE);
+        g_return_val_if_fail (count >= 0, FALSE);
   
-  priv = loader->priv;
+        priv = loader->priv;
 
-  /* we expect it's not to be closed */
-  g_return_val_if_fail (priv->closed == FALSE, FALSE);
+        /* we expect it's not to be closed */
+        g_return_val_if_fail (priv->closed == FALSE, FALSE);
   
-  if (priv->image_module == NULL)
-    {
-      gint eaten;
+        if (priv->image_module == NULL)
+                {
+                        gint eaten;
       
-      eaten = gdk_pixbuf_loader_eat_header_write (loader, buf, count, error);
-      if (eaten <= 0)
-	return FALSE;
+                        eaten = gdk_pixbuf_loader_eat_header_write (loader, buf, count, error);
+                        if (eaten <= 0)
+                                return FALSE;
       
-      count -= eaten;
-      buf += eaten;
-    }
-  
-  if (count > 0 && priv->image_module->load_increment)
-    {
-      gboolean retval;
-      retval = priv->image_module->load_increment (priv->context, buf, count,
-                                                   error);
-      if (!retval && error && *error == NULL)
-        {
-          /* Fix up busted image loader */
-          g_warning ("Bug! loader '%s' didn't set an error on failure",
-                     priv->image_module->module_name);
-          g_set_error (error,
-                       GDK_PIXBUF_ERROR,
-                       GDK_PIXBUF_ERROR_FAILED,
-                       _("Internal error: Image loader module '%s'"
-                         " failed to begin loading an image, but didn't"
-                         " give a reason for the failure"),
-                       priv->image_module->module_name);
-        }
-
-      return retval;
-    }
+                        count -= eaten;
+                        buf += eaten;
+                }
+  
+        if (count > 0 && priv->image_module->load_increment)
+                {
+                        gboolean retval;
+                        retval = priv->image_module->load_increment (priv->context, buf, count,
+                                                                     error);
+                        if (!retval && error && *error == NULL)
+                                {
+                                        /* Fix up busted image loader */
+                                        g_warning ("Bug! loader '%s' didn't set an error on failure",
+                                                   priv->image_module->module_name);
+                                        g_set_error (error,
+                                                     GDK_PIXBUF_ERROR,
+                                                     GDK_PIXBUF_ERROR_FAILED,
+                                                     _("Internal error: Image loader module '%s'"
+                                                       " failed to begin loading an image, but didn't"
+                                                       " give a reason for the failure"),
+                                                     priv->image_module->module_name);
+                                }
+
+                        return retval;
+                }
       
-  return TRUE;
+        return TRUE;
 }
 
 /**
@@ -470,7 +474,7 @@ gdk_pixbuf_loader_write (GdkPixbufLoader *loader,
 GdkPixbufLoader *
 gdk_pixbuf_loader_new (void)
 {
-  return g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
+        return g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
 }
 
 /**
@@ -491,21 +495,21 @@ GdkPixbufLoader *
 gdk_pixbuf_loader_new_with_type (const char *image_type,
                                  GError    **error)
 {
-  GdkPixbufLoader *retval;
-  GError *tmp;
+        GdkPixbufLoader *retval;
+        GError *tmp;
   
-  retval = g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
+        retval = g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
 
-  tmp = NULL;
-  gdk_pixbuf_loader_load_module(retval, image_type, &tmp);
-  if (tmp != NULL)
-    {
-      g_propagate_error (error, tmp);
-      g_object_unref (retval);
-      return NULL;
-    }
+        tmp = NULL;
+        gdk_pixbuf_loader_load_module(retval, image_type, &tmp);
+        if (tmp != NULL)
+                {
+                        g_propagate_error (error, tmp);
+                        g_object_unref (retval);
+                        return NULL;
+                }
 
-  return retval;
+        return retval;
 }
 
 /**
@@ -530,17 +534,17 @@ gdk_pixbuf_loader_new_with_type (const char *image_type,
 GdkPixbuf *
 gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader)
 {
-  GdkPixbufLoaderPrivate *priv;
+        GdkPixbufLoaderPrivate *priv;
   
-  g_return_val_if_fail (loader != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
+        g_return_val_if_fail (loader != NULL, NULL);
+        g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
   
-  priv = loader->priv;
+        priv = loader->priv;
 
-  if (priv->animation)
-    return gdk_pixbuf_animation_get_static_image (priv->animation);
-  else
-    return NULL;
+        if (priv->animation)
+                return gdk_pixbuf_animation_get_static_image (priv->animation);
+        else
+                return NULL;
 }
 
 /**
@@ -559,14 +563,14 @@ gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader)
 GdkPixbufAnimation *
 gdk_pixbuf_loader_get_animation (GdkPixbufLoader *loader)
 {
-  GdkPixbufLoaderPrivate *priv;
+        GdkPixbufLoaderPrivate *priv;
   
-  g_return_val_if_fail (loader != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
+        g_return_val_if_fail (loader != NULL, NULL);
+        g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
   
-  priv = loader->priv;
+        priv = loader->priv;
   
-  return priv->animation;
+        return priv->animation;
 }
 
 /**
@@ -591,60 +595,62 @@ gboolean
 gdk_pixbuf_loader_close (GdkPixbufLoader *loader,
                          GError         **error)
 {
-  GdkPixbufLoaderPrivate *priv;
-  gboolean retval = TRUE;
-  
-  g_return_val_if_fail (loader != NULL, TRUE);
-  g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), TRUE);
-  
-  priv = loader->priv;
-  
-  /* we expect it's not closed */
-  g_return_val_if_fail (priv->closed == FALSE, TRUE);
-  
-  /* We have less the 128 bytes in the image.  Flush it, and keep going. */
-  if (priv->image_module == NULL)
-    {
-      GError *tmp = NULL;
-      gdk_pixbuf_loader_load_module (loader, NULL, &tmp);
-      if (tmp != NULL)
-	{
-	  g_propagate_error (error, tmp);
-	  retval = FALSE;
-	}
-    }  
-
-  if (priv->image_module && priv->image_module->stop_load && priv->context) {
-    if (!priv->image_module->stop_load (priv->context, error))
-      retval = FALSE;
-  }
-  
-  priv->closed = TRUE;
-
-  if (priv->needs_scale) {
-    GdkPixbuf *tmp, *pixbuf;
-
-    tmp = gdk_pixbuf_animation_get_static_image (priv->animation);
-    g_object_ref (tmp);
-    pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, tmp->has_alpha, 8, priv->width, priv->height);
-    g_object_unref (priv->animation);
-    priv->animation = gdk_pixbuf_non_anim_new (pixbuf);
-    g_object_unref (pixbuf);
-    g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
-    gdk_pixbuf_scale (tmp, pixbuf, 0, 0, priv->width, priv->height, 0, 0,
-		      (double) priv->width / tmp->width,
-		      (double) priv->height / tmp->height,
-		      GDK_INTERP_BILINEAR); 
-    g_object_unref (tmp);
-
-    g_signal_emit (loader, pixbuf_loader_signals[AREA_UPDATED], 0, 
-		   0, 0, priv->width, priv->height);
-  }
-
-  
-  g_signal_emit (loader, pixbuf_loader_signals[CLOSED], 0);
-
-  return retval;
+        GdkPixbufLoaderPrivate *priv;
+        gboolean retval = TRUE;
+  
+        g_return_val_if_fail (loader != NULL, TRUE);
+        g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), TRUE);
+  
+        priv = loader->priv;
+  
+        /* we expect it's not closed */
+        g_return_val_if_fail (priv->closed == FALSE, TRUE);
+  
+        /* We have less the 128 bytes in the image.  Flush it, and keep going. */
+        if (priv->image_module == NULL)
+                {
+                        GError *tmp = NULL;
+                        gdk_pixbuf_loader_load_module (loader, NULL, &tmp);
+                        if (tmp != NULL)
+                                {
+                                        g_propagate_error (error, tmp);
+                                        retval = FALSE;
+                                }
+                }  
+
+        if (priv->image_module && priv->image_module->stop_load && priv->context) 
+                {
+                        if (!priv->image_module->stop_load (priv->context, error))
+                                retval = FALSE;
+                }
+  
+        priv->closed = TRUE;
+
+        if (priv->needs_scale) 
+                {
+                        GdkPixbuf *tmp, *pixbuf;
+                        
+                        tmp = gdk_pixbuf_animation_get_static_image (priv->animation);
+                        g_object_ref (tmp);
+                        pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, tmp->has_alpha, 8, priv->width, priv->height);
+                        g_object_unref (priv->animation);
+                        priv->animation = gdk_pixbuf_non_anim_new (pixbuf);
+                        g_object_unref (pixbuf);
+                        g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
+                        gdk_pixbuf_scale (tmp, pixbuf, 0, 0, priv->width, priv->height, 0, 0,
+                                          (double) priv->width / tmp->width,
+                                          (double) priv->height / tmp->height,
+                                          GDK_INTERP_BILINEAR); 
+                        g_object_unref (tmp);
+                        
+                        g_signal_emit (loader, pixbuf_loader_signals[AREA_UPDATED], 0, 
+                                       0, 0, priv->width, priv->height);
+                }
+
+        
+        g_signal_emit (loader, pixbuf_loader_signals[CLOSED], 0);
+
+        return retval;
 }
 
 /**
@@ -660,17 +666,17 @@ gdk_pixbuf_loader_close (GdkPixbufLoader *loader,
 GdkPixbufFormat *
 gdk_pixbuf_loader_get_format (GdkPixbufLoader *loader)
 {
-  GdkPixbufLoaderPrivate *priv;
+        GdkPixbufLoaderPrivate *priv;
   
-  g_return_val_if_fail (loader != NULL, NULL);
-  g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
+        g_return_val_if_fail (loader != NULL, NULL);
+        g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
   
-  priv = loader->priv;
+        priv = loader->priv;
 
-  if (priv->image_module)
-    return _gdk_pixbuf_get_format (priv->image_module);
-  else
-    return NULL;
+        if (priv->image_module)
+                return _gdk_pixbuf_get_format (priv->image_module);
+        else
+                return NULL;
 }