From f67f342d1ed1ed36d9b10072e1e1ae3800bf1ed7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicolas=20L=C3=A9veill=C3=A9?= <nicolas@uucidl.com>
Date: Sat, 17 May 2014 13:38:56 +0200
Subject: [PATCH 1/3] whitespace-cleanup (removed tabs)

---
 src/image.c | 3436 +++++++++++++++++++++++++++++------------------------------
 1 file changed, 1718 insertions(+), 1718 deletions(-)

diff --git a/src/image.c b/src/image.c
index 047f751..7ae417c 100644
--- a/src/image.c
+++ b/src/image.c
@@ -206,7 +206,7 @@ x_allocate_bitmap_record (struct frame *f)
 
   dpyinfo->bitmaps =
     xpalloc (dpyinfo->bitmaps, &dpyinfo->bitmaps_size,
-	     10, -1, sizeof *dpyinfo->bitmaps);
+             10, -1, sizeof *dpyinfo->bitmaps);
   return ++dpyinfo->bitmaps_last;
 }
 
@@ -229,7 +229,7 @@ x_create_bitmap_from_data (struct frame *f, char *bits, unsigned int width, unsi
 #ifdef HAVE_X_WINDOWS
   Pixmap bitmap;
   bitmap = XCreateBitmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-				  bits, width, height);
+                                  bits, width, height);
   if (! bitmap)
     return -1;
 #endif /* HAVE_X_WINDOWS */
@@ -237,9 +237,9 @@ x_create_bitmap_from_data (struct frame *f, char *bits, unsigned int width, unsi
 #ifdef HAVE_NTGUI
   Pixmap bitmap;
   bitmap = CreateBitmap (width, height,
-			 FRAME_DISPLAY_INFO (XFRAME (frame))->n_planes,
-			 FRAME_DISPLAY_INFO (XFRAME (frame))->n_cbits,
-			 bits);
+                         FRAME_DISPLAY_INFO (XFRAME (frame))->n_planes,
+                         FRAME_DISPLAY_INFO (XFRAME (frame))->n_cbits,
+                         bits);
   if (! bitmap)
     return -1;
 #endif /* HAVE_NTGUI */
@@ -318,24 +318,24 @@ x_create_bitmap_from_file (struct frame *f, Lisp_Object file)
   for (id = 0; id < dpyinfo->bitmaps_last; ++id)
     {
       if (dpyinfo->bitmaps[id].refcount
-	  && dpyinfo->bitmaps[id].file
-	  && !strcmp (dpyinfo->bitmaps[id].file, SSDATA (file)))
-	{
-	  ++dpyinfo->bitmaps[id].refcount;
-	  return id + 1;
-	}
+          && dpyinfo->bitmaps[id].file
+          && !strcmp (dpyinfo->bitmaps[id].file, SSDATA (file)))
+        {
+          ++dpyinfo->bitmaps[id].refcount;
+          return id + 1;
+        }
     }
 
   /* Search bitmap-file-path for the file, if appropriate.  */
   if (openp (Vx_bitmap_file_path, file, Qnil, &found,
-	     make_number (R_OK), false)
+             make_number (R_OK), false)
       < 0)
     return -1;
 
   filename = SSDATA (found);
 
   result = XReadBitmapFile (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-			    filename, &width, &height, &bitmap, &xhot, &yhot);
+                            filename, &width, &height, &bitmap, &xhot, &yhot);
   if (result != BitmapSuccess)
     return -1;
 
@@ -390,11 +390,11 @@ x_destroy_bitmap (struct frame *f, ptrdiff_t id)
       Bitmap_Record *bm = &dpyinfo->bitmaps[id - 1];
 
       if (--bm->refcount == 0)
-	{
-	  block_input ();
-	  free_bitmap_record (dpyinfo, bm);
-	  unblock_input ();
-	}
+        {
+          block_input ();
+          free_bitmap_record (dpyinfo, bm);
+          unblock_input ();
+        }
     }
 }
 
@@ -414,14 +414,14 @@ x_destroy_all_bitmaps (Display_Info *dpyinfo)
 }
 
 static bool x_create_x_image_and_pixmap (struct frame *, int, int, int,
-					 XImagePtr *, Pixmap *);
+                                         XImagePtr *, Pixmap *);
 static void x_destroy_x_image (XImagePtr ximg);
 
 #ifdef HAVE_NTGUI
 static XImagePtr_or_DC image_get_x_image_or_dc (struct frame *, struct image *,
-						bool, HGDIOBJ *);
+                                                bool, HGDIOBJ *);
 static void image_unget_x_image_or_dc (struct image *, bool, XImagePtr_or_DC,
-				       HGDIOBJ);
+                                       HGDIOBJ);
 #else
 static XImagePtr image_get_x_image (struct frame *, struct image *, bool);
 static void image_unget_x_image (struct image *, bool, XImagePtr);
@@ -469,7 +469,7 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id)
 
   block_input ();
   ximg = XGetImage (FRAME_X_DISPLAY (f), pixmap, 0, 0, width, height,
-		    ~0, ZPixmap);
+                    ~0, ZPixmap);
 
   if (!ximg)
     {
@@ -491,30 +491,30 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id)
   for (y = 0; y < ximg->height; ++y)
     {
       for (x = 0; x < ximg->width; ++x)
-	{
-	  xp = x != ximg->width - 1 ? x + 1 : 0;
-	  xm = x != 0 ? x - 1 : ximg->width - 1;
-	  yp = y != ximg->height - 1 ? y + 1 : 0;
-	  ym = y != 0 ? y - 1 : ximg->height - 1;
-	  if (XGetPixel (ximg, x, y) == bg
-	      && XGetPixel (ximg, x, yp) == bg
-	      && XGetPixel (ximg, x, ym) == bg
-	      && XGetPixel (ximg, xp, y) == bg
-	      && XGetPixel (ximg, xp, yp) == bg
-	      && XGetPixel (ximg, xp, ym) == bg
-	      && XGetPixel (ximg, xm, y) == bg
-	      && XGetPixel (ximg, xm, yp) == bg
-	      && XGetPixel (ximg, xm, ym) == bg)
-	    XPutPixel (mask_img, x, y, 0);
-	  else
-	    XPutPixel (mask_img, x, y, 1);
-	}
+        {
+          xp = x != ximg->width - 1 ? x + 1 : 0;
+          xm = x != 0 ? x - 1 : ximg->width - 1;
+          yp = y != ximg->height - 1 ? y + 1 : 0;
+          ym = y != 0 ? y - 1 : ximg->height - 1;
+          if (XGetPixel (ximg, x, y) == bg
+              && XGetPixel (ximg, x, yp) == bg
+              && XGetPixel (ximg, x, ym) == bg
+              && XGetPixel (ximg, xp, y) == bg
+              && XGetPixel (ximg, xp, yp) == bg
+              && XGetPixel (ximg, xp, ym) == bg
+              && XGetPixel (ximg, xm, y) == bg
+              && XGetPixel (ximg, xm, yp) == bg
+              && XGetPixel (ximg, xm, ym) == bg)
+            XPutPixel (mask_img, x, y, 0);
+          else
+            XPutPixel (mask_img, x, y, 1);
+        }
     }
 
   eassert (input_blocked_p ());
   gc = XCreateGC (FRAME_X_DISPLAY (f), mask, 0, NULL);
   XPutImage (FRAME_X_DISPLAY (f), mask, gc, mask_img, 0, 0, 0, 0,
-	     width, height);
+             width, height);
   XFreeGC (FRAME_X_DISPLAY (f), gc);
 
   dpyinfo->bitmaps[id - 1].have_mask = true;
@@ -528,7 +528,7 @@ x_create_bitmap_mask (struct frame *f, ptrdiff_t id)
 
 
 /***********************************************************************
-			    Image types
+                            Image types
  ***********************************************************************/
 
 /* List of supported image types.  Use define_image_type to add new
@@ -593,13 +593,13 @@ define_image_type (struct image_type *type)
       /* If we failed to load the library before, don't try again.  */
       Lisp_Object tested = Fassq (target_type, Vlibrary_cache);
       if (CONSP (tested) && NILP (XCDR (tested)))
-	type_valid = 0;
+        type_valid = 0;
       else
 #endif
-	{
-	  type_valid = type->init ();
-	  CACHE_IMAGE_TYPE (target_type, type_valid ? Qt : Qnil);
-	}
+        {
+          type_valid = type->init ();
+          CACHE_IMAGE_TYPE (target_type, type_valid ? Qt : Qnil);
+        }
     }
 
   if (type_valid)
@@ -635,19 +635,19 @@ valid_image_p (Lisp_Object object)
       Lisp_Object tem;
 
       for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem))
-	if (EQ (XCAR (tem), QCtype))
-	  {
-	    tem = XCDR (tem);
-	    if (CONSP (tem) && SYMBOLP (XCAR (tem)))
-	      {
-		struct image_type *type;
-		type = lookup_image_type (XCAR (tem));
-		if (type)
-		  valid_p = type->valid_p (object);
-	      }
+        if (EQ (XCAR (tem), QCtype))
+          {
+            tem = XCDR (tem);
+            if (CONSP (tem) && SYMBOLP (XCAR (tem)))
+              {
+                struct image_type *type;
+                type = lookup_image_type (XCAR (tem));
+                if (type)
+                  valid_p = type->valid_p (object);
+              }
 
-	    break;
-	  }
+            break;
+          }
     }
 
   return valid_p;
@@ -669,7 +669,7 @@ image_error (const char *format, Lisp_Object arg1, Lisp_Object arg2)
 
 
 /***********************************************************************
-			 Image specifications
+                         Image specifications
  ***********************************************************************/
 
 enum image_value_type
@@ -717,7 +717,7 @@ struct image_keyword
 
 static bool
 parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
-		  int nkeywords, Lisp_Object type)
+                  int nkeywords, Lisp_Object type)
 {
   int i;
   Lisp_Object plist;
@@ -734,107 +734,107 @@ parse_image_spec (Lisp_Object spec, struct image_keyword *keywords,
       key = XCAR (plist);
       plist = XCDR (plist);
       if (!SYMBOLP (key))
-	return 0;
+        return 0;
 
       /* There must follow a value.  */
       if (!CONSP (plist))
-	return 0;
+        return 0;
       value = XCAR (plist);
       plist = XCDR (plist);
 
       /* Find key in KEYWORDS.  Error if not found.  */
       for (i = 0; i < nkeywords; ++i)
-	if (strcmp (keywords[i].name, SSDATA (SYMBOL_NAME (key))) == 0)
-	  break;
+        if (strcmp (keywords[i].name, SSDATA (SYMBOL_NAME (key))) == 0)
+          break;
 
       if (i == nkeywords)
-	continue;
+        continue;
 
       /* Record that we recognized the keyword.  If a keywords
-	 was found more than once, it's an error.  */
+         was found more than once, it's an error.  */
       keywords[i].value = value;
       if (keywords[i].count > 1)
-	return 0;
+        return 0;
       ++keywords[i].count;
 
       /* Check type of value against allowed type.  */
       switch (keywords[i].type)
-	{
-	case IMAGE_STRING_VALUE:
-	  if (!STRINGP (value))
-	    return 0;
-	  break;
-
-	case IMAGE_STRING_OR_NIL_VALUE:
-	  if (!STRINGP (value) && !NILP (value))
-	    return 0;
-	  break;
-
-	case IMAGE_SYMBOL_VALUE:
-	  if (!SYMBOLP (value))
-	    return 0;
-	  break;
-
-	case IMAGE_POSITIVE_INTEGER_VALUE:
-	  if (! RANGED_INTEGERP (1, value, INT_MAX))
-	    return 0;
-	  break;
-
-	case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR:
-	  if (RANGED_INTEGERP (0, value, INT_MAX))
-	    break;
-	  if (CONSP (value)
-	      && RANGED_INTEGERP (0, XCAR (value), INT_MAX)
-	      && RANGED_INTEGERP (0, XCDR (value), INT_MAX))
-	    break;
-	  return 0;
-
-	case IMAGE_ASCENT_VALUE:
-	  if (SYMBOLP (value) && EQ (value, Qcenter))
-	    break;
-	  else if (RANGED_INTEGERP (0, value, 100))
-	    break;
-	  return 0;
-
-	case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
-	  /* Unlike the other integer-related cases, this one does not
-	     verify that VALUE fits in 'int'.  This is because callers
-	     want EMACS_INT.  */
-	  if (!INTEGERP (value) || XINT (value) < 0)
-	    return 0;
-	  break;
-
-	case IMAGE_DONT_CHECK_VALUE_TYPE:
-	  break;
-
-	case IMAGE_FUNCTION_VALUE:
-	  value = indirect_function (value);
-	  if (!NILP (Ffunctionp (value)))
-	    break;
-	  return 0;
-
-	case IMAGE_NUMBER_VALUE:
-	  if (!INTEGERP (value) && !FLOATP (value))
-	    return 0;
-	  break;
-
-	case IMAGE_INTEGER_VALUE:
-	  if (! TYPE_RANGED_INTEGERP (int, value))
-	    return 0;
-	  break;
-
-	case IMAGE_BOOL_VALUE:
-	  if (!NILP (value) && !EQ (value, Qt))
-	    return 0;
-	  break;
-
-	default:
-	  emacs_abort ();
-	  break;
-	}
+        {
+        case IMAGE_STRING_VALUE:
+          if (!STRINGP (value))
+            return 0;
+          break;
+
+        case IMAGE_STRING_OR_NIL_VALUE:
+          if (!STRINGP (value) && !NILP (value))
+            return 0;
+          break;
+
+        case IMAGE_SYMBOL_VALUE:
+          if (!SYMBOLP (value))
+            return 0;
+          break;
+
+        case IMAGE_POSITIVE_INTEGER_VALUE:
+          if (! RANGED_INTEGERP (1, value, INT_MAX))
+            return 0;
+          break;
+
+        case IMAGE_NON_NEGATIVE_INTEGER_VALUE_OR_PAIR:
+          if (RANGED_INTEGERP (0, value, INT_MAX))
+            break;
+          if (CONSP (value)
+              && RANGED_INTEGERP (0, XCAR (value), INT_MAX)
+              && RANGED_INTEGERP (0, XCDR (value), INT_MAX))
+            break;
+          return 0;
+
+        case IMAGE_ASCENT_VALUE:
+          if (SYMBOLP (value) && EQ (value, Qcenter))
+            break;
+          else if (RANGED_INTEGERP (0, value, 100))
+            break;
+          return 0;
+
+        case IMAGE_NON_NEGATIVE_INTEGER_VALUE:
+          /* Unlike the other integer-related cases, this one does not
+             verify that VALUE fits in 'int'.  This is because callers
+             want EMACS_INT.  */
+          if (!INTEGERP (value) || XINT (value) < 0)
+            return 0;
+          break;
+
+        case IMAGE_DONT_CHECK_VALUE_TYPE:
+          break;
+
+        case IMAGE_FUNCTION_VALUE:
+          value = indirect_function (value);
+          if (!NILP (Ffunctionp (value)))
+            break;
+          return 0;
+
+        case IMAGE_NUMBER_VALUE:
+          if (!INTEGERP (value) && !FLOATP (value))
+            return 0;
+          break;
+
+        case IMAGE_INTEGER_VALUE:
+          if (! TYPE_RANGED_INTEGERP (int, value))
+            return 0;
+          break;
+
+        case IMAGE_BOOL_VALUE:
+          if (!NILP (value) && !EQ (value, Qt))
+            return 0;
+          break;
+
+        default:
+          emacs_abort ();
+          break;
+        }
 
       if (EQ (key, QCtype) && !EQ (type, value))
-	return 0;
+        return 0;
     }
 
   /* Check that all mandatory fields are present.  */
@@ -862,11 +862,11 @@ image_spec_value (Lisp_Object spec, Lisp_Object key, bool *found)
        tail = XCDR (XCDR (tail)))
     {
       if (EQ (XCAR (tail), key))
-	{
-	  if (found)
-	    *found = 1;
-	  return XCAR (XCDR (tail));
-	}
+        {
+          if (found)
+            *found = 1;
+          return XCAR (XCDR (tail));
+        }
     }
 
   if (found)
@@ -895,10 +895,10 @@ or omitted means use the selected frame.  */)
       int height = img->height + 2 * img->vmargin;
 
       if (NILP (pixels))
-	size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
-		      make_float ((double) height / FRAME_LINE_HEIGHT (f)));
+        size = Fcons (make_float ((double) width / FRAME_COLUMN_WIDTH (f)),
+                      make_float ((double) height / FRAME_LINE_HEIGHT (f)));
       else
-	size = Fcons (make_number (width), make_number (height));
+        size = Fcons (make_number (width), make_number (height));
     }
   else
     error ("Invalid image specification");
@@ -922,7 +922,7 @@ or omitted means use the selected frame.  */)
       ptrdiff_t id = lookup_image (f, spec);
       struct image *img = IMAGE_FROM_ID (f, id);
       if (img->mask)
-	mask = Qt;
+        mask = Qt;
     }
   else
     error ("Invalid image specification");
@@ -952,7 +952,7 @@ or omitted means use the selected frame.  */)
 
 
 /***********************************************************************
-		 Image type independent image structures
+                 Image type independent image structures
  ***********************************************************************/
 
 #define MAX_IMAGE_SIZE 10.0
@@ -989,12 +989,12 @@ free_image (struct frame *f, struct image *img)
 
       /* Remove IMG from the hash table of its cache.  */
       if (img->prev)
-	img->prev->next = img->next;
+        img->prev->next = img->next;
       else
-	c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
+        c->buckets[img->hash % IMAGE_CACHE_BUCKETS_SIZE] = img->next;
 
       if (img->next)
-	img->next->prev = img->prev;
+        img->next->prev = img->prev;
 
       c->images[img->id] = NULL;
 
@@ -1016,18 +1016,18 @@ check_image_size (struct frame *f, int width, int height)
 
   if (INTEGERP (Vmax_image_size))
     return (width <= XINT (Vmax_image_size)
-	    && height <= XINT (Vmax_image_size));
+            && height <= XINT (Vmax_image_size));
   else if (FLOATP (Vmax_image_size))
     {
       if (f != NULL)
-	{
-	  w = FRAME_PIXEL_WIDTH (f);
-	  h = FRAME_PIXEL_HEIGHT (f);
-	}
+        {
+          w = FRAME_PIXEL_WIDTH (f);
+          h = FRAME_PIXEL_HEIGHT (f);
+        }
       else
-	w = h = 1024;  /* Arbitrary size for unknown frame. */
+        w = h = 1024;  /* Arbitrary size for unknown frame. */
       return (width <= XFLOAT_DATA (Vmax_image_size) * w
-	      && height <= XFLOAT_DATA (Vmax_image_size) * h);
+              && height <= XFLOAT_DATA (Vmax_image_size) * h);
     }
   else
     return 1;
@@ -1077,23 +1077,23 @@ image_ascent (struct image *img, struct face *face, struct glyph_slice *slice)
   if (img->ascent == CENTERED_IMAGE_ASCENT)
     {
       if (face->font)
-	{
+        {
 #ifdef HAVE_NTGUI
-	  /* W32 specific version.  Why?. ++kfs  */
-	  ascent = height / 2 - (FONT_DESCENT (face->font)
-				 - FONT_BASE (face->font)) / 2;
+          /* W32 specific version.  Why?. ++kfs  */
+          ascent = height / 2 - (FONT_DESCENT (face->font)
+                                 - FONT_BASE (face->font)) / 2;
 #else
-	  /* This expression is arranged so that if the image can't be
-	     exactly centered, it will be moved slightly up.  This is
-	     because a typical font is `top-heavy' (due to the presence
-	     uppercase letters), so the image placement should err towards
-	     being top-heavy too.  It also just generally looks better.  */
-	  ascent = (height + FONT_BASE (face->font)
+          /* This expression is arranged so that if the image can't be
+             exactly centered, it will be moved slightly up.  This is
+             because a typical font is `top-heavy' (due to the presence
+             uppercase letters), so the image placement should err towards
+             being top-heavy too.  It also just generally looks better.  */
+          ascent = (height + FONT_BASE (face->font)
                     - FONT_DESCENT (face->font) + 1) / 2;
 #endif /* HAVE_NTGUI */
-	}
+        }
       else
-	ascent = height / 2;
+        ascent = height / 2;
     }
   else
     ascent = height * (img->ascent / 100.0);
@@ -1109,7 +1109,7 @@ image_ascent (struct image *img, struct face *face, struct glyph_slice *slice)
 
 static RGB_PIXEL_COLOR
 four_corners_best (XImagePtr_or_DC ximg, int *corners,
-		   unsigned long width, unsigned long height)
+                   unsigned long width, unsigned long height)
 {
   RGB_PIXEL_COLOR corner_pixels[4], best IF_LINT (= 0);
   int i, best_count;
@@ -1136,11 +1136,11 @@ four_corners_best (XImagePtr_or_DC ximg, int *corners,
       int j, n;
 
       for (j = n = 0; j < 4; ++j)
-	if (corner_pixels[i] == corner_pixels[j])
-	  ++n;
+        if (corner_pixels[i] == corner_pixels[j])
+          ++n;
 
       if (n > best_count)
-	best = corner_pixels[i], best_count = n;
+        best = corner_pixels[i], best_count = n;
     }
 
   return best;
@@ -1183,12 +1183,12 @@ image_background (struct image *img, struct frame *f, XImagePtr_or_DC ximg)
 #endif /* HAVE_NTGUI */
 
       if (free_ximg)
-	ximg = image_get_x_image_or_dc (f, img, 0, &prev);
+        ximg = image_get_x_image_or_dc (f, img, 0, &prev);
 
       img->background = four_corners_best (ximg, img->corners, img->width, img->height);
 
       if (free_ximg)
-	image_unget_x_image_or_dc (img, 0, ximg, prev);
+        image_unget_x_image_or_dc (img, 0, ximg, prev);
 
       img->background_valid = 1;
     }
@@ -1207,23 +1207,23 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D
     /* IMG doesn't have a background yet, try to guess a reasonable value.  */
     {
       if (img->mask)
-	{
-	  bool free_mask = !mask;
+        {
+          bool free_mask = !mask;
 #ifdef HAVE_NTGUI
-	  HGDIOBJ prev;
+          HGDIOBJ prev;
 #endif /* HAVE_NTGUI */
 
-	  if (free_mask)
-	    mask = image_get_x_image_or_dc (f, img, 1, &prev);
+          if (free_mask)
+            mask = image_get_x_image_or_dc (f, img, 1, &prev);
 
-	  img->background_transparent
-	    = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
+          img->background_transparent
+            = (four_corners_best (mask, img->corners, img->width, img->height) == PIX_MASK_RETAIN);
 
-	  if (free_mask)
-	    image_unget_x_image_or_dc (img, 1, mask, prev);
-	}
+          if (free_mask)
+            image_unget_x_image_or_dc (img, 1, mask, prev);
+        }
       else
-	img->background_transparent = 0;
+        img->background_transparent = 0;
 
       img->background_transparent_valid = 1;
     }
@@ -1245,7 +1245,7 @@ x_query_frame_background_color (struct frame *f, XColor *bgcolor)
 
 
 /***********************************************************************
-		  Helper functions for X image types
+                  Helper functions for X image types
  ***********************************************************************/
 
 /* Clear X resources of image IMG on frame F according to FLAGS.
@@ -1265,37 +1265,37 @@ x_clear_image_1 (struct frame *f, struct image *img, int flags)
   if (flags & CLEAR_IMAGE_PIXMAP)
     {
       if (img->pixmap)
-	{
-	  Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
-	  img->pixmap = NO_PIXMAP;
-	  /* NOTE (HAVE_NS): background color is NOT an indexed color! */
-	  img->background_valid = 0;
-	}
+        {
+          Free_Pixmap (FRAME_X_DISPLAY (f), img->pixmap);
+          img->pixmap = NO_PIXMAP;
+          /* NOTE (HAVE_NS): background color is NOT an indexed color! */
+          img->background_valid = 0;
+        }
 #ifdef HAVE_X_WINDOWS
       if (img->ximg)
-	{
-	  x_destroy_x_image (img->ximg);
-	  img->ximg = NULL;
-	  img->background_valid = 0;
-	}
+        {
+          x_destroy_x_image (img->ximg);
+          img->ximg = NULL;
+          img->background_valid = 0;
+        }
 #endif
     }
 
   if (flags & CLEAR_IMAGE_MASK)
     {
       if (img->mask)
-	{
-	  Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
-	  img->mask = NO_PIXMAP;
-	  img->background_transparent_valid = 0;
-	}
+        {
+          Free_Pixmap (FRAME_X_DISPLAY (f), img->mask);
+          img->mask = NO_PIXMAP;
+          img->background_transparent_valid = 0;
+        }
 #ifdef HAVE_X_WINDOWS
       if (img->mask_img)
-	{
-	  x_destroy_x_image (img->mask_img);
-	  img->mask_img = NULL;
-	  img->background_transparent_valid = 0;
-	}
+        {
+          x_destroy_x_image (img->mask_img);
+          img->mask_img = NULL;
+          img->background_transparent_valid = 0;
+        }
 #endif
     }
 
@@ -1319,7 +1319,7 @@ x_clear_image (struct frame *f, struct image *img)
 {
   block_input ();
   x_clear_image_1 (f, img,
-		   CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_MASK | CLEAR_IMAGE_COLORS);
+                   CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_MASK | CLEAR_IMAGE_COLORS);
   unblock_input ();
 }
 
@@ -1331,7 +1331,7 @@ x_clear_image (struct frame *f, struct image *img)
 
 static unsigned long
 x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name,
-		     unsigned long dflt)
+                     unsigned long dflt)
 {
   XColor color;
   unsigned long result;
@@ -1340,10 +1340,10 @@ x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name,
 
   if (x_defined_color (f, SSDATA (color_name), &color, 1)
       && img->ncolors < min (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *img->colors,
-			     INT_MAX))
+                             INT_MAX))
     {
       /* This isn't called frequently so we get away with simply
-	 reallocating the color vector to the needed size, here.  */
+         reallocating the color vector to the needed size, here.  */
       ptrdiff_t ncolors = img->ncolors + 1;
       img->colors = xrealloc (img->colors, ncolors * sizeof *img->colors);
       img->colors[ncolors - 1] = color.pixel;
@@ -1359,7 +1359,7 @@ x_alloc_image_color (struct frame *f, struct image *img, Lisp_Object color_name,
 
 
 /***********************************************************************
-			     Image Cache
+                             Image Cache
  ***********************************************************************/
 
 static void cache_image (struct frame *f, struct image *img);
@@ -1405,9 +1405,9 @@ search_image_cache (struct frame *f, Lisp_Object spec, EMACS_UINT hash)
 
   for (img = c->buckets[i]; img; img = img->next)
     if (img->hash == hash
-	&& !NILP (Fequal (img->spec, spec))
-	&& img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
-	&& img->frame_background == FRAME_BACKGROUND_PIXEL (f))
+        && !NILP (Fequal (img->spec, spec))
+        && img->frame_foreground == FRAME_FOREGROUND_PIXEL (f)
+        && img->frame_background == FRAME_BACKGROUND_PIXEL (f))
       break;
   return img;
 }
@@ -1423,7 +1423,7 @@ uncache_image (struct frame *f, Lisp_Object spec)
     {
       free_image (f, img);
       /* As display glyphs may still be referring to the image ID, we
-	 must garbage the frame (Bug#6426).  */
+         must garbage the frame (Bug#6426).  */
       SET_FRAME_GARBAGED (f);
     }
 }
@@ -1444,7 +1444,7 @@ free_image_cache (struct frame *f)
       eassert (c->refcount == 0);
 
       for (i = 0; i < c->used; ++i)
-	free_image (f, c->images[i]);
+        free_image (f, c->images[i]);
       xfree (c->images);
       xfree (c->buckets);
       xfree (c);
@@ -1471,72 +1471,72 @@ clear_image_cache (struct frame *f, Lisp_Object filter)
       ptrdiff_t i, nfreed = 0;
 
       /* Block input so that we won't be interrupted by a SIGIO
-	 while being in an inconsistent state.  */
+         while being in an inconsistent state.  */
       block_input ();
 
       if (!NILP (filter))
-	{
-	  /* Filter image cache.  */
-	  for (i = 0; i < c->used; ++i)
-	    {
-	      struct image *img = c->images[i];
-	      if (img && (EQ (Qt, filter)
-			  || !NILP (Fmember (filter, img->dependencies))))
-		{
-		  free_image (f, img);
-		  ++nfreed;
-		}
-	    }
-	}
+        {
+          /* Filter image cache.  */
+          for (i = 0; i < c->used; ++i)
+            {
+              struct image *img = c->images[i];
+              if (img && (EQ (Qt, filter)
+                          || !NILP (Fmember (filter, img->dependencies))))
+                {
+                  free_image (f, img);
+                  ++nfreed;
+                }
+            }
+        }
       else if (INTEGERP (Vimage_cache_eviction_delay))
-	{
-	  /* Free cache based on timestamp.  */
-	  struct timespec old, t;
-	  double delay;
-	  ptrdiff_t nimages = 0;
-
-	  for (i = 0; i < c->used; ++i)
-	    if (c->images[i])
-	      nimages++;
-
-	  /* If the number of cached images has grown unusually large,
-	     decrease the cache eviction delay (Bug#6230).  */
-	  delay = XINT (Vimage_cache_eviction_delay);
-	  if (nimages > 40)
-	    delay = 1600 * delay / nimages / nimages;
-	  delay = max (delay, 1);
-
-	  t = current_timespec ();
-	  old = timespec_sub (t, dtotimespec (delay));
-
-	  for (i = 0; i < c->used; ++i)
-	    {
-	      struct image *img = c->images[i];
-	      if (img && timespec_cmp (img->timestamp, old) < 0)
-		{
-		  free_image (f, img);
-		  ++nfreed;
-		}
-	    }
-	}
+        {
+          /* Free cache based on timestamp.  */
+          struct timespec old, t;
+          double delay;
+          ptrdiff_t nimages = 0;
+
+          for (i = 0; i < c->used; ++i)
+            if (c->images[i])
+              nimages++;
+
+          /* If the number of cached images has grown unusually large,
+             decrease the cache eviction delay (Bug#6230).  */
+          delay = XINT (Vimage_cache_eviction_delay);
+          if (nimages > 40)
+            delay = 1600 * delay / nimages / nimages;
+          delay = max (delay, 1);
+
+          t = current_timespec ();
+          old = timespec_sub (t, dtotimespec (delay));
+
+          for (i = 0; i < c->used; ++i)
+            {
+              struct image *img = c->images[i];
+              if (img && timespec_cmp (img->timestamp, old) < 0)
+                {
+                  free_image (f, img);
+                  ++nfreed;
+                }
+            }
+        }
 
       /* We may be clearing the image cache because, for example,
-	 Emacs was iconified for a longer period of time.  In that
-	 case, current matrices may still contain references to
-	 images freed above.  So, clear these matrices.  */
+         Emacs was iconified for a longer period of time.  In that
+         case, current matrices may still contain references to
+         images freed above.  So, clear these matrices.  */
       if (nfreed)
-	{
-	  Lisp_Object tail, frame;
+        {
+          Lisp_Object tail, frame;
 
-	  FOR_EACH_FRAME (tail, frame)
-	    {
-	      struct frame *fr = XFRAME (frame);
-	      if (FRAME_IMAGE_CACHE (fr) == c)
-		clear_current_matrices (fr);
-	    }
+          FOR_EACH_FRAME (tail, frame)
+            {
+              struct frame *fr = XFRAME (frame);
+              if (FRAME_IMAGE_CACHE (fr) == c)
+                clear_current_matrices (fr);
+            }
 
-	  windows_or_buffers_changed = 19;
-	}
+          windows_or_buffers_changed = 19;
+        }
 
       unblock_input ();
     }
@@ -1591,11 +1591,11 @@ FRAME t means refresh the image on all frames.  */)
     {
       Lisp_Object tail;
       FOR_EACH_FRAME (tail, frame)
-	{
-	  struct frame *f = XFRAME (frame);
-	  if (FRAME_WINDOW_P (f))
-	    uncache_image (f, spec);
-	}
+        {
+          struct frame *f = XFRAME (frame);
+          if (FRAME_WINDOW_P (f))
+            uncache_image (f, spec);
+        }
     }
   else
     uncache_image (decode_window_system_frame (frame), spec);
@@ -1619,57 +1619,57 @@ postprocess_image (struct frame *f, struct image *img)
       spec = img->spec;
 
       /* `:heuristic-mask t'
-	 `:mask heuristic'
-	 means build a mask heuristically.
-	 `:heuristic-mask (R G B)'
-	 `:mask (heuristic (R G B))'
-	 means build a mask from color (R G B) in the
-	 image.
-	 `:mask nil'
-	 means remove a mask, if any.  */
+         `:mask heuristic'
+         means build a mask heuristically.
+         `:heuristic-mask (R G B)'
+         `:mask (heuristic (R G B))'
+         means build a mask from color (R G B) in the
+         image.
+         `:mask nil'
+         means remove a mask, if any.  */
 
       mask = image_spec_value (spec, QCheuristic_mask, NULL);
       if (!NILP (mask))
-	x_build_heuristic_mask (f, img, mask);
+        x_build_heuristic_mask (f, img, mask);
       else
-	{
-	  bool found_p;
-
-	  mask = image_spec_value (spec, QCmask, &found_p);
-
-	  if (EQ (mask, Qheuristic))
-	    x_build_heuristic_mask (f, img, Qt);
-	  else if (CONSP (mask)
-		   && EQ (XCAR (mask), Qheuristic))
-	    {
-	      if (CONSP (XCDR (mask)))
-		x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
-	      else
-		x_build_heuristic_mask (f, img, XCDR (mask));
-	    }
-	  else if (NILP (mask) && found_p && img->mask)
-	    x_clear_image_1 (f, img, CLEAR_IMAGE_MASK);
-	}
+        {
+          bool found_p;
+
+          mask = image_spec_value (spec, QCmask, &found_p);
+
+          if (EQ (mask, Qheuristic))
+            x_build_heuristic_mask (f, img, Qt);
+          else if (CONSP (mask)
+                   && EQ (XCAR (mask), Qheuristic))
+            {
+              if (CONSP (XCDR (mask)))
+                x_build_heuristic_mask (f, img, XCAR (XCDR (mask)));
+              else
+                x_build_heuristic_mask (f, img, XCDR (mask));
+            }
+          else if (NILP (mask) && found_p && img->mask)
+            x_clear_image_1 (f, img, CLEAR_IMAGE_MASK);
+        }
 
 
       /* Should we apply an image transformation algorithm?  */
       conversion = image_spec_value (spec, QCconversion, NULL);
       if (EQ (conversion, Qdisabled))
-	x_disable_image (f, img);
+        x_disable_image (f, img);
       else if (EQ (conversion, Qlaplace))
-	x_laplace (f, img);
+        x_laplace (f, img);
       else if (EQ (conversion, Qemboss))
-	x_emboss (f, img);
+        x_emboss (f, img);
       else if (CONSP (conversion)
-	       && EQ (XCAR (conversion), Qedge_detection))
-	{
-	  Lisp_Object tem;
-	  tem = XCDR (conversion);
-	  if (CONSP (tem))
-	    x_edge_detection (f, img,
-			      Fplist_get (tem, QCmatrix),
-			      Fplist_get (tem, QCcolor_adjustment));
-	}
+               && EQ (XCAR (conversion), Qedge_detection))
+        {
+          Lisp_Object tem;
+          tem = XCDR (conversion);
+          if (CONSP (tem))
+            x_edge_detection (f, img,
+                              Fplist_get (tem, QCmatrix),
+                              Fplist_get (tem, QCcolor_adjustment));
+        }
     }
 }
 
@@ -1708,68 +1708,68 @@ lookup_image (struct frame *f, Lisp_Object spec)
       img->frame_background = FRAME_BACKGROUND_PIXEL (f);
 
       /* If we can't load the image, and we don't have a width and
-	 height, use some arbitrary width and height so that we can
-	 draw a rectangle for it.  */
+         height, use some arbitrary width and height so that we can
+         draw a rectangle for it.  */
       if (img->load_failed_p)
-	{
-	  Lisp_Object value;
-
-	  value = image_spec_value (spec, QCwidth, NULL);
-	  img->width = (INTEGERP (value)
-			? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
-	  value = image_spec_value (spec, QCheight, NULL);
-	  img->height = (INTEGERP (value)
-			 ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
-	}
+        {
+          Lisp_Object value;
+
+          value = image_spec_value (spec, QCwidth, NULL);
+          img->width = (INTEGERP (value)
+                        ? XFASTINT (value) : DEFAULT_IMAGE_WIDTH);
+          value = image_spec_value (spec, QCheight, NULL);
+          img->height = (INTEGERP (value)
+                         ? XFASTINT (value) : DEFAULT_IMAGE_HEIGHT);
+        }
       else
-	{
-	  /* Handle image type independent image attributes
-	     `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
-	     `:background COLOR'.  */
-	  Lisp_Object ascent, margin, relief, bg;
-	  int relief_bound;
-
-	  ascent = image_spec_value (spec, QCascent, NULL);
-	  if (INTEGERP (ascent))
-	    img->ascent = XFASTINT (ascent);
-	  else if (EQ (ascent, Qcenter))
-	    img->ascent = CENTERED_IMAGE_ASCENT;
-
-	  margin = image_spec_value (spec, QCmargin, NULL);
-	  if (INTEGERP (margin))
-	    img->vmargin = img->hmargin = XFASTINT (margin);
-	  else if (CONSP (margin))
-	    {
-	      img->hmargin = XFASTINT (XCAR (margin));
-	      img->vmargin = XFASTINT (XCDR (margin));
-	    }
-
-	  relief = image_spec_value (spec, QCrelief, NULL);
-	  relief_bound = INT_MAX - max (img->hmargin, img->vmargin);
-	  if (RANGED_INTEGERP (- relief_bound, relief, relief_bound))
-	    {
-	      img->relief = XINT (relief);
-	      img->hmargin += eabs (img->relief);
-	      img->vmargin += eabs (img->relief);
-	    }
-
-	  if (! img->background_valid)
-	    {
-	      bg = image_spec_value (img->spec, QCbackground, NULL);
-	      if (!NILP (bg))
-		{
-		  img->background
-		    = x_alloc_image_color (f, img, bg,
-					   FRAME_BACKGROUND_PIXEL (f));
-		  img->background_valid = 1;
-		}
-	    }
-
-	  /* Do image transformations and compute masks, unless we
-	     don't have the image yet.  */
-	  if (!EQ (*img->type->type, Qpostscript))
-	    postprocess_image (f, img);
-	}
+        {
+          /* Handle image type independent image attributes
+             `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
+             `:background COLOR'.  */
+          Lisp_Object ascent, margin, relief, bg;
+          int relief_bound;
+
+          ascent = image_spec_value (spec, QCascent, NULL);
+          if (INTEGERP (ascent))
+            img->ascent = XFASTINT (ascent);
+          else if (EQ (ascent, Qcenter))
+            img->ascent = CENTERED_IMAGE_ASCENT;
+
+          margin = image_spec_value (spec, QCmargin, NULL);
+          if (INTEGERP (margin))
+            img->vmargin = img->hmargin = XFASTINT (margin);
+          else if (CONSP (margin))
+            {
+              img->hmargin = XFASTINT (XCAR (margin));
+              img->vmargin = XFASTINT (XCDR (margin));
+            }
+
+          relief = image_spec_value (spec, QCrelief, NULL);
+          relief_bound = INT_MAX - max (img->hmargin, img->vmargin);
+          if (RANGED_INTEGERP (- relief_bound, relief, relief_bound))
+            {
+              img->relief = XINT (relief);
+              img->hmargin += eabs (img->relief);
+              img->vmargin += eabs (img->relief);
+            }
+
+          if (! img->background_valid)
+            {
+              bg = image_spec_value (img->spec, QCbackground, NULL);
+              if (!NILP (bg))
+                {
+                  img->background
+                    = x_alloc_image_color (f, img, bg,
+                                           FRAME_BACKGROUND_PIXEL (f));
+                  img->background_valid = 1;
+                }
+            }
+
+          /* Do image transformations and compute masks, unless we
+             don't have the image yet.  */
+          if (!EQ (*img->type->type, Qpostscript))
+            postprocess_image (f, img);
+        }
 
       unblock_input ();
     }
@@ -1838,15 +1838,15 @@ mark_image_cache (struct image_cache *c)
     {
       ptrdiff_t i;
       for (i = 0; i < c->used; ++i)
-	if (c->images[i])
-	  mark_image (c->images[i]);
+        if (c->images[i])
+          mark_image (c->images[i]);
     }
 }
 
 
 
 /***********************************************************************
-			  X / NS / W32 support code
+                          X / NS / W32 support code
  ***********************************************************************/
 
 #ifdef WINDOWSNT
@@ -1893,7 +1893,7 @@ x_check_image_size (XImagePtr ximg, int width, int height)
       bytes_per_line = (width >> 3) + ((width & 7) != 0);
     }
   return (width <= (INT_MAX - (bitmap_pad - 1)) / depth
-	  && height <= X_IMAGE_BYTES_MAX / bytes_per_line);
+          && height <= X_IMAGE_BYTES_MAX / bytes_per_line);
 #else
   /* FIXME: Implement this check for the HAVE_NS and HAVE_NTGUI cases.
      For now, assume that every image size is allowed on these systems.  */
@@ -1912,7 +1912,7 @@ x_check_image_size (XImagePtr ximg, int width, int height)
 
 static bool
 x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
-			     XImagePtr *ximg, Pixmap *pixmap)
+                             XImagePtr *ximg, Pixmap *pixmap)
 {
 #ifdef HAVE_X_WINDOWS
   Display *display = FRAME_X_DISPLAY (f);
@@ -1924,8 +1924,8 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
   if (depth <= 0)
     depth = DefaultDepthOfScreen (screen);
   *ximg = XCreateImage (display, DefaultVisualOfScreen (screen),
-			depth, ZPixmap, 0, NULL, width, height,
-			depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
+                        depth, ZPixmap, 0, NULL, width, height,
+                        depth > 16 ? 32 : depth > 8 ? 16 : 8, 0);
   if (*ximg == NULL)
     {
       image_error ("Unable to allocate X image", Qnil, Qnil);
@@ -1937,7 +1937,7 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
       x_destroy_x_image (*ximg);
       *ximg = NULL;
       image_error ("Image too large (%dx%d)",
-		   make_number (width), make_number (height));
+                   make_number (width), make_number (height));
       return 0;
     }
 
@@ -2016,9 +2016,9 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
   /* Create a DIBSection and raster array for the bitmap,
      and store its handle in *pixmap.  */
   *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
-			      (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
-			      /* casting avoids a GCC warning */
-			      (void **)&((*ximg)->data), NULL, 0);
+                              (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
+                              /* casting avoids a GCC warning */
+                              (void **)&((*ximg)->data), NULL, 0);
 
   /* Realize display palette and garbage all frames. */
   release_frame_dc (f, hdc);
@@ -2112,13 +2112,13 @@ x_put_x_image (struct frame *f, XImagePtr ximg, Pixmap pixmap, int width, int he
 
 static bool
 image_create_x_image_and_pixmap (struct frame *f, struct image *img,
-				 int width, int height, int depth,
-				 XImagePtr *ximg, bool mask_p)
+                                 int width, int height, int depth,
+                                 XImagePtr *ximg, bool mask_p)
 {
   eassert ((!mask_p ? img->pixmap : img->mask) == NO_PIXMAP);
 
   return x_create_x_image_and_pixmap (f, width, height, depth, ximg,
-				      !mask_p ? &img->pixmap : &img->mask);
+                                      !mask_p ? &img->pixmap : &img->mask);
 }
 
 /* Put X image XIMG into image IMG on frame F, as a mask if and only
@@ -2129,7 +2129,7 @@ image_create_x_image_and_pixmap (struct frame *f, struct image *img,
 
 static void
 image_put_x_image (struct frame *f, struct image *img, XImagePtr ximg,
-		   bool mask_p)
+                   bool mask_p)
 {
 #ifdef HAVE_X_WINDOWS
   if (!mask_p)
@@ -2144,7 +2144,7 @@ image_put_x_image (struct frame *f, struct image *img, XImagePtr ximg,
     }
 #else
   x_put_x_image (f, ximg, !mask_p ? img->pixmap : img->mask,
-		 img->width, img->height);
+                 img->width, img->height);
   x_destroy_x_image (ximg);
 #endif
 }
@@ -2178,7 +2178,7 @@ image_sync_to_pixmaps (struct frame *f, struct image *img)
 
 static XImagePtr_or_DC
 image_get_x_image_or_dc (struct frame *f, struct image *img, bool mask_p,
-			 HGDIOBJ *prev)
+                         HGDIOBJ *prev)
 {
   HDC frame_dc = get_frame_dc (f);
   XImagePtr_or_DC ximg = CreateCompatibleDC (frame_dc);
@@ -2191,7 +2191,7 @@ image_get_x_image_or_dc (struct frame *f, struct image *img, bool mask_p,
 
 static void
 image_unget_x_image_or_dc (struct image *img, bool mask_p,
-			   XImagePtr_or_DC ximg, HGDIOBJ prev)
+                           XImagePtr_or_DC ximg, HGDIOBJ prev)
 {
   SelectObject (ximg, prev);
   DeleteDC (ximg);
@@ -2210,7 +2210,7 @@ image_get_x_image (struct frame *f, struct image *img, bool mask_p)
     return ximg_in_img;
   else
     return XGetImage (FRAME_X_DISPLAY (f), !mask_p ? img->pixmap : img->mask,
-		      0, 0, img->width, img->height, ~0, ZPixmap);
+                      0, 0, img->width, img->height, ~0, ZPixmap);
 #elif defined (HAVE_NS)
   XImagePtr pixmap = !mask_p ? img->pixmap : img->mask;
 
@@ -2237,7 +2237,7 @@ image_unget_x_image (struct image *img, bool mask_p, XImagePtr ximg)
 
 
 /***********************************************************************
-			      File Handling
+                              File Handling
  ***********************************************************************/
 
 /* Find image file FILE.  Look in data-directory/images, then
@@ -2253,8 +2253,8 @@ x_find_image_file (Lisp_Object file)
   /* TODO I think this should use something like image-load-path
      instead.  Unfortunately, that can contain non-string elements.  */
   search_path = Fcons (Fexpand_file_name (build_string ("images"),
-					  Vdata_directory),
-		       Vx_bitmap_file_path);
+                                          Vdata_directory),
+                       Vx_bitmap_file_path);
 
   /* Try to find FILE in data-directory/images, then x-bitmap-file-path.  */
   fd = openp (search_path, file, Qnil, &file_found, Qnil, false);
@@ -2265,7 +2265,7 @@ x_find_image_file (Lisp_Object file)
     {
       file_found = ENCODE_FILE (file_found);
       if (fd != -2)
-	emacs_close (fd);
+        emacs_close (fd);
     }
 
   return file_found;
@@ -2289,20 +2289,20 @@ slurp_file (char *file, ptrdiff_t *size)
       record_unwind_protect_ptr (fclose_unwind, fp);
 
       if (fstat (fileno (fp), &st) == 0
-	  && 0 <= st.st_size && st.st_size < min (PTRDIFF_MAX, SIZE_MAX))
-	{
-	  /* Report an error if we read past the purported EOF.
-	     This can happen if the file grows as we read it.  */
-	  ptrdiff_t buflen = st.st_size;
-	  buf = xmalloc (buflen + 1);
-	  if (fread (buf, 1, buflen + 1, fp) == buflen)
-	    *size = buflen;
-	  else
-	    {
-	      xfree (buf);
-	      buf = NULL;
-	    }
-	}
+          && 0 <= st.st_size && st.st_size < min (PTRDIFF_MAX, SIZE_MAX))
+        {
+          /* Report an error if we read past the purported EOF.
+             This can happen if the file grows as we read it.  */
+          ptrdiff_t buflen = st.st_size;
+          buf = xmalloc (buflen + 1);
+          if (fread (buf, 1, buflen + 1, fp) == buflen)
+            *size = buflen;
+          else
+            {
+              xfree (buf);
+              buf = NULL;
+            }
+        }
 
       unbind_to (count, Qnil);
     }
@@ -2313,7 +2313,7 @@ slurp_file (char *file, ptrdiff_t *size)
 
 
 /***********************************************************************
-			      XBM images
+                              XBM images
  ***********************************************************************/
 
 static bool xbm_load (struct frame *f, struct image *img);
@@ -2425,13 +2425,13 @@ xbm_image_p (Lisp_Object object)
   if (kw[XBM_FILE].count)
     {
       if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_DATA].count)
-	return 0;
+        return 0;
     }
   else if (kw[XBM_DATA].count && xbm_file_p (kw[XBM_DATA].value))
     {
       /* In-memory XBM file.  */
       if (kw[XBM_WIDTH].count || kw[XBM_HEIGHT].count || kw[XBM_FILE].count)
-	return 0;
+        return 0;
     }
   else
     {
@@ -2440,58 +2440,58 @@ xbm_image_p (Lisp_Object object)
 
       /* Entries for `:width', `:height' and `:data' must be present.  */
       if (!kw[XBM_WIDTH].count
-	  || !kw[XBM_HEIGHT].count
-	  || !kw[XBM_DATA].count)
-	return 0;
+          || !kw[XBM_HEIGHT].count
+          || !kw[XBM_DATA].count)
+        return 0;
 
       data = kw[XBM_DATA].value;
       width = XFASTINT (kw[XBM_WIDTH].value);
       height = XFASTINT (kw[XBM_HEIGHT].value);
 
       /* Check type of data, and width and height against contents of
-	 data.  */
+         data.  */
       if (VECTORP (data))
-	{
-	  EMACS_INT i;
-
-	  /* Number of elements of the vector must be >= height.  */
-	  if (ASIZE (data) < height)
-	    return 0;
-
-	  /* Each string or bool-vector in data must be large enough
-	     for one line of the image.  */
-	  for (i = 0; i < height; ++i)
-	    {
-	      Lisp_Object elt = AREF (data, i);
-
-	      if (STRINGP (elt))
-		{
-		  if (SCHARS (elt)
-		      < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
-		    return 0;
-		}
-	      else if (BOOL_VECTOR_P (elt))
-		{
-		  if (bool_vector_size (elt) < width)
-		    return 0;
-		}
-	      else
-		return 0;
-	    }
-	}
+        {
+          EMACS_INT i;
+
+          /* Number of elements of the vector must be >= height.  */
+          if (ASIZE (data) < height)
+            return 0;
+
+          /* Each string or bool-vector in data must be large enough
+             for one line of the image.  */
+          for (i = 0; i < height; ++i)
+            {
+              Lisp_Object elt = AREF (data, i);
+
+              if (STRINGP (elt))
+                {
+                  if (SCHARS (elt)
+                      < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR)
+                    return 0;
+                }
+              else if (BOOL_VECTOR_P (elt))
+                {
+                  if (bool_vector_size (elt) < width)
+                    return 0;
+                }
+              else
+                return 0;
+            }
+        }
       else if (STRINGP (data))
-	{
-	  if (SCHARS (data)
-	      < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
-	    return 0;
-	}
+        {
+          if (SCHARS (data)
+              < (width + BITS_PER_CHAR - 1) / BITS_PER_CHAR * height)
+            return 0;
+        }
       else if (BOOL_VECTOR_P (data))
-	{
-	  if (bool_vector_size (data) / height < width)
-	    return 0;
-	}
+        {
+          if (bool_vector_size (data) / height < width)
+            return 0;
+        }
       else
-	return 0;
+        return 0;
     }
 
   return 1;
@@ -2522,42 +2522,42 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
       int value = 0, digit;
 
       if (c == '0' && *s < end)
-	{
-	  c = *(*s)++;
-	  if (c == 'x' || c == 'X')
-	    {
-	      while (*s < end)
-		{
-		  c = *(*s)++;
-		  if (c_isdigit (c))
-		    digit = c - '0';
-		  else if (c >= 'a' && c <= 'f')
-		    digit = c - 'a' + 10;
-		  else if (c >= 'A' && c <= 'F')
-		    digit = c - 'A' + 10;
-		  else
-		    break;
-		  value = 16 * value + digit;
-		}
-	    }
-	  else if (c_isdigit (c))
-	    {
-	      value = c - '0';
-	      while (*s < end
-		     && (c = *(*s)++, c_isdigit (c)))
-		value = 8 * value + c - '0';
-	    }
-	}
+        {
+          c = *(*s)++;
+          if (c == 'x' || c == 'X')
+            {
+              while (*s < end)
+                {
+                  c = *(*s)++;
+                  if (c_isdigit (c))
+                    digit = c - '0';
+                  else if (c >= 'a' && c <= 'f')
+                    digit = c - 'a' + 10;
+                  else if (c >= 'A' && c <= 'F')
+                    digit = c - 'A' + 10;
+                  else
+                    break;
+                  value = 16 * value + digit;
+                }
+            }
+          else if (c_isdigit (c))
+            {
+              value = c - '0';
+              while (*s < end
+                     && (c = *(*s)++, c_isdigit (c)))
+                value = 8 * value + c - '0';
+            }
+        }
       else
-	{
-	  value = c - '0';
-	  while (*s < end
-		 && (c = *(*s)++, c_isdigit (c)))
-	    value = 10 * value + c - '0';
-	}
+        {
+          value = c - '0';
+          while (*s < end
+                 && (c = *(*s)++, c_isdigit (c)))
+            value = 10 * value + c - '0';
+        }
 
       if (*s < end)
-	*s = *s - 1;
+        *s = *s - 1;
       *ival = value;
       c = XBM_TK_NUMBER;
     }
@@ -2565,11 +2565,11 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
     {
       *sval++ = c;
       while (*s < end
-	     && (c = *(*s)++, (c_isalnum (c) || c == '_')))
-	*sval++ = c;
+             && (c = *(*s)++, (c_isalnum (c) || c == '_')))
+        *sval++ = c;
       *sval = 0;
       if (*s < end)
-	*s = *s - 1;
+        *s = *s - 1;
       c = XBM_TK_IDENT;
     }
   else if (c == '/' && **s == '*')
@@ -2577,12 +2577,12 @@ xbm_scan (unsigned char **s, unsigned char *end, char *sval, int *ival)
       /* C-style comment.  */
       ++*s;
       while (**s && (**s != '*' || *(*s + 1) != '/'))
-	++*s;
+        ++*s;
       if (**s)
-	{
-	  *s += 2;
-	  goto loop;
-	}
+        {
+          *s += 2;
+          goto loop;
+        }
     }
 
   return c;
@@ -2596,9 +2596,9 @@ w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
 {
   static unsigned char swap_nibble[16]
     = { 0x0, 0x8, 0x4, 0xc,    /* 0000 1000 0100 1100 */
-	0x2, 0xa, 0x6, 0xe,    /* 0010 1010 0110 1110 */
-	0x1, 0x9, 0x5, 0xd,    /* 0001 1001 0101 1101 */
-	0x3, 0xb, 0x7, 0xf };  /* 0011 1011 0111 1111 */
+        0x2, 0xa, 0x6, 0xe,    /* 0010 1010 0110 1110 */
+        0x1, 0x9, 0x5, 0xd,    /* 0001 1001 0101 1101 */
+        0x3, 0xb, 0x7, 0xf };  /* 0011 1011 0111 1111 */
   int i, j, w1, w2;
   unsigned char *bits, *p;
   HBITMAP bmp;
@@ -2611,12 +2611,12 @@ w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
     {
       p = bits + i*w2;
       for (j = 0; j < w1; j++)
-	{
-	  /* Bitswap XBM bytes to match how Windows does things.  */
-	  unsigned char c = *data++;
-	  *p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
-				 | (swap_nibble[(c>>4) & 0xf]));
-	}
+        {
+          /* Bitswap XBM bytes to match how Windows does things.  */
+          unsigned char c = *data++;
+          *p++ = (unsigned char)((swap_nibble[c & 0xf] << 4)
+                                 | (swap_nibble[(c>>4) & 0xf]));
+        }
     }
   bmp = CreateBitmap (width, height, 1, 1, (char *) bits);
 
@@ -2625,7 +2625,7 @@ w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
 
 static void
 convert_mono_to_color_image (struct frame *f, struct image *img,
-			     COLORREF foreground, COLORREF background)
+                             COLORREF foreground, COLORREF background)
 {
   HDC hdc, old_img_dc, new_img_dc;
   HGDIOBJ old_prev, new_prev;
@@ -2644,7 +2644,7 @@ convert_mono_to_color_image (struct frame *f, struct image *img,
   SetBkColor (new_img_dc, foreground);
 
   BitBlt (new_img_dc, 0, 0, img->width, img->height, old_img_dc,
-	  0, 0, SRCCOPY);
+          0, 0, SRCCOPY);
 
   SelectObject (old_img_dc, old_prev);
   SelectObject (new_img_dc, new_prev);
@@ -2668,8 +2668,8 @@ convert_mono_to_color_image (struct frame *f, struct image *img,
 
 static void
 Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data,
-				RGB_PIXEL_COLOR fg, RGB_PIXEL_COLOR bg,
-				bool non_default_colors)
+                                RGB_PIXEL_COLOR fg, RGB_PIXEL_COLOR bg,
+                                bool non_default_colors)
 {
 #ifdef HAVE_NTGUI
   img->pixmap
@@ -2686,11 +2686,11 @@ Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data,
   img->pixmap =
    (x_check_image_size (0, img->width, img->height)
     ? XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f),
-				   FRAME_X_WINDOW (f),
-				   data,
-				   img->width, img->height,
-				   fg, bg,
-				   DefaultDepthOfScreen (FRAME_X_SCREEN (f)))
+                                   FRAME_X_WINDOW (f),
+                                   data,
+                                   img->width, img->height,
+                                   fg, bg,
+                                   DefaultDepthOfScreen (FRAME_X_SCREEN (f)))
     : NO_PIXMAP);
 #endif /* !HAVE_NTGUI && !HAVE_NS */
 }
@@ -2708,8 +2708,8 @@ Create_Pixmap_From_Bitmap_Data (struct frame *f, struct image *img, char *data,
 
 static bool
 xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *end,
-		      int *width, int *height, char **data,
-		      bool inhibit_image_error)
+                      int *width, int *height, char **data,
+                      bool inhibit_image_error)
 {
   unsigned char *s = contents;
   char buffer[BUFSIZ];
@@ -2726,8 +2726,8 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
 #define expect(TOKEN)		\
   do				\
     {				\
-      if (LA1 != (TOKEN)) 	\
-	goto failure;		\
+      if (LA1 != (TOKEN))       \
+        goto failure;		\
       match ();			\
     }				\
   while (0)
@@ -2751,21 +2751,21 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
       expect (XBM_TK_IDENT);
 
       if (LA1 == XBM_TK_NUMBER)
-	{
-	  char *q = strrchr (buffer, '_');
-	  q = q ? q + 1 : buffer;
-	  if (strcmp (q, "width") == 0)
-	    *width = value;
-	  else if (strcmp (q, "height") == 0)
-	    *height = value;
-	}
+        {
+          char *q = strrchr (buffer, '_');
+          q = q ? q + 1 : buffer;
+          if (strcmp (q, "width") == 0)
+            *width = value;
+          else if (strcmp (q, "height") == 0)
+            *height = value;
+        }
       expect (XBM_TK_NUMBER);
     }
 
   if (!check_image_size (f, *width, *height))
     {
       if (!inhibit_image_error)
-	image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
+        image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       goto failure;
     }
   else if (data == NULL)
@@ -2776,21 +2776,21 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
   if (LA1 == XBM_TK_IDENT)
     {
       if (strcmp (buffer, "unsigned") == 0)
-	{
-	  match ();
-	  expect_ident ("char");
-	}
+        {
+          match ();
+          expect_ident ("char");
+        }
       else if (strcmp (buffer, "short") == 0)
-	{
-	  match ();
-	  v10 = 1;
-	  if (*width % 16 && *width % 16 < 9)
-	    padding_p = 1;
-	}
+        {
+          match ();
+          v10 = 1;
+          if (*width % 16 && *width % 16 < 9)
+            padding_p = 1;
+        }
       else if (strcmp (buffer, "char") == 0)
-	match ();
+        match ();
       else
-	goto failure;
+        goto failure;
     }
   else
     goto failure;
@@ -2804,8 +2804,8 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
   if (! x_check_image_size (0, *width, *height))
     {
       if (!inhibit_image_error)
-	image_error ("Image too large (%dx%d)",
-		     make_number (*width), make_number (*height));
+        image_error ("Image too large (%dx%d)",
+                     make_number (*width), make_number (*height));
       goto failure;
     }
   bytes_per_line = (*width + 7) / 8 + padding_p;
@@ -2815,34 +2815,34 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
   if (v10)
     {
       for (i = 0; i < nbytes; i += 2)
-	{
-	  int val = value;
-	  expect (XBM_TK_NUMBER);
+        {
+          int val = value;
+          expect (XBM_TK_NUMBER);
 
-	  *p++ = XBM_BIT_SHUFFLE (val);
-	  if (!padding_p || ((i + 2) % bytes_per_line))
-	    *p++ = XBM_BIT_SHUFFLE (value >> 8);
+          *p++ = XBM_BIT_SHUFFLE (val);
+          if (!padding_p || ((i + 2) % bytes_per_line))
+            *p++ = XBM_BIT_SHUFFLE (value >> 8);
 
-	  if (LA1 == ',' || LA1 == '}')
-	    match ();
-	  else
-	    goto failure;
-	}
+          if (LA1 == ',' || LA1 == '}')
+            match ();
+          else
+            goto failure;
+        }
     }
   else
     {
       for (i = 0; i < nbytes; ++i)
-	{
-	  int val = value;
-	  expect (XBM_TK_NUMBER);
+        {
+          int val = value;
+          expect (XBM_TK_NUMBER);
 
-	  *p++ = XBM_BIT_SHUFFLE (val);
+          *p++ = XBM_BIT_SHUFFLE (val);
 
-	  if (LA1 == ',' || LA1 == '}')
-	    match ();
-	  else
-	    goto failure;
-	}
+          if (LA1 == ',' || LA1 == '}')
+            match ();
+          else
+            goto failure;
+        }
     }
 
  success:
@@ -2869,14 +2869,14 @@ xbm_read_bitmap_data (struct frame *f, unsigned char *contents, unsigned char *e
 
 static bool
 xbm_load_image (struct frame *f, struct image *img, unsigned char *contents,
-		unsigned char *end)
+                unsigned char *end)
 {
   bool rc;
   char *data;
   bool success_p = 0;
 
   rc = xbm_read_bitmap_data (f, contents, end, &img->width, &img->height,
-			     &data, 0);
+                             &data, 0);
   if (rc)
     {
       unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
@@ -2889,31 +2889,31 @@ xbm_load_image (struct frame *f, struct image *img, unsigned char *contents,
       /* Get foreground and background colors, maybe allocate colors.  */
       value = image_spec_value (img->spec, QCforeground, NULL);
       if (!NILP (value))
-	{
-	  foreground = x_alloc_image_color (f, img, value, foreground);
-	  non_default_colors = 1;
-	}
+        {
+          foreground = x_alloc_image_color (f, img, value, foreground);
+          non_default_colors = 1;
+        }
       value = image_spec_value (img->spec, QCbackground, NULL);
       if (!NILP (value))
-	{
-	  background = x_alloc_image_color (f, img, value, background);
-	  img->background = background;
-	  img->background_valid = 1;
-	  non_default_colors = 1;
-	}
+        {
+          background = x_alloc_image_color (f, img, value, background);
+          img->background = background;
+          img->background_valid = 1;
+          non_default_colors = 1;
+        }
 
       Create_Pixmap_From_Bitmap_Data (f, img, data,
-				      foreground, background,
-				      non_default_colors);
+                                      foreground, background,
+                                      non_default_colors);
       xfree (data);
 
       if (img->pixmap == NO_PIXMAP)
-	{
-	  x_clear_image (f, img);
-	  image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
-	}
+        {
+          x_clear_image (f, img);
+          image_error ("Unable to create X pixmap for `%s'", img->spec, Qnil);
+        }
       else
-	success_p = 1;
+        success_p = 1;
     }
   else
     image_error ("Error loading XBM image `%s'", img->spec, Qnil);
@@ -2929,9 +2929,9 @@ xbm_file_p (Lisp_Object data)
 {
   int w, h;
   return (STRINGP (data)
-	  && xbm_read_bitmap_data (NULL, SDATA (data),
-				   (SDATA (data) + SBYTES (data)),
-				   &w, &h, NULL, 1));
+          && xbm_read_bitmap_data (NULL, SDATA (data),
+                                   (SDATA (data) + SBYTES (data)),
+                                   &w, &h, NULL, 1));
 }
 
 
@@ -2956,17 +2956,17 @@ xbm_load (struct frame *f, struct image *img)
 
       file = x_find_image_file (file_name);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", file_name, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", file_name, Qnil);
+          return 0;
+        }
 
       contents = slurp_file (SSDATA (file), &size);
       if (contents == NULL)
-	{
-	  image_error ("Error loading XBM image `%s'", img->spec, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Error loading XBM image `%s'", img->spec, Qnil);
+          return 0;
+        }
 
       success_p = xbm_load_image (f, img, contents, contents + size);
       xfree (contents);
@@ -2993,61 +2993,61 @@ xbm_load (struct frame *f, struct image *img)
 
       /* Get specified width, and height.  */
       if (!in_memory_file_p)
-	{
-	  img->width = XFASTINT (fmt[XBM_WIDTH].value);
-	  img->height = XFASTINT (fmt[XBM_HEIGHT].value);
-	  eassert (img->width > 0 && img->height > 0);
-	  if (!check_image_size (f, img->width, img->height))
-	    {
-	      image_error ("Invalid image size (see `max-image-size')",
-			   Qnil, Qnil);
-	      return 0;
-	    }
-	}
+        {
+          img->width = XFASTINT (fmt[XBM_WIDTH].value);
+          img->height = XFASTINT (fmt[XBM_HEIGHT].value);
+          eassert (img->width > 0 && img->height > 0);
+          if (!check_image_size (f, img->width, img->height))
+            {
+              image_error ("Invalid image size (see `max-image-size')",
+                           Qnil, Qnil);
+              return 0;
+            }
+        }
 
       /* Get foreground and background colors, maybe allocate colors.  */
       if (fmt[XBM_FOREGROUND].count
-	  && STRINGP (fmt[XBM_FOREGROUND].value))
-	{
-	  foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
-					    foreground);
-	  non_default_colors = 1;
-	}
+          && STRINGP (fmt[XBM_FOREGROUND].value))
+        {
+          foreground = x_alloc_image_color (f, img, fmt[XBM_FOREGROUND].value,
+                                            foreground);
+          non_default_colors = 1;
+        }
 
       if (fmt[XBM_BACKGROUND].count
-	  && STRINGP (fmt[XBM_BACKGROUND].value))
-	{
-	  background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
-					    background);
-	  non_default_colors = 1;
-	}
+          && STRINGP (fmt[XBM_BACKGROUND].value))
+        {
+          background = x_alloc_image_color (f, img, fmt[XBM_BACKGROUND].value,
+                                            background);
+          non_default_colors = 1;
+        }
 
       if (in_memory_file_p)
-	success_p = xbm_load_image (f, img, SDATA (data),
-				    (SDATA (data)
-				     + SBYTES (data)));
+        success_p = xbm_load_image (f, img, SDATA (data),
+                                    (SDATA (data)
+                                     + SBYTES (data)));
       else
-	{
-	  if (VECTORP (data))
-	    {
-	      int i;
-	      char *p;
-	      int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
-
-	      p = bits = alloca (nbytes * img->height);
-	      for (i = 0; i < img->height; ++i, p += nbytes)
-		{
-		  Lisp_Object line = AREF (data, i);
-		  if (STRINGP (line))
-		    memcpy (p, SDATA (line), nbytes);
-		  else
-		    memcpy (p, bool_vector_data (line), nbytes);
-		}
-	    }
-	  else if (STRINGP (data))
-	    bits = SSDATA (data);
-	  else
-	    bits = (char *) bool_vector_data (data);
+        {
+          if (VECTORP (data))
+            {
+              int i;
+              char *p;
+              int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
+
+              p = bits = alloca (nbytes * img->height);
+              for (i = 0; i < img->height; ++i, p += nbytes)
+                {
+                  Lisp_Object line = AREF (data, i);
+                  if (STRINGP (line))
+                    memcpy (p, SDATA (line), nbytes);
+                  else
+                    memcpy (p, bool_vector_data (line), nbytes);
+                }
+            }
+          else if (STRINGP (data))
+            bits = SSDATA (data);
+          else
+            bits = (char *) bool_vector_data (data);
 
 #ifdef HAVE_NTGUI
           {
@@ -3062,24 +3062,24 @@ xbm_load (struct frame *f, struct image *img)
               bits[i] = XBM_BIT_SHUFFLE (invertedBits[i]);
           }
 #endif
-	  /* Create the pixmap.  */
-
-	  if (x_check_image_size (0, img->width, img->height))
-	    Create_Pixmap_From_Bitmap_Data (f, img, bits,
-					    foreground, background,
-					    non_default_colors);
-	  else
-	    img->pixmap = NO_PIXMAP;
-
-	  if (img->pixmap)
-	    success_p = 1;
-	  else
-	    {
-	      image_error ("Unable to create pixmap for XBM image `%s'",
-			   img->spec, Qnil);
-	      x_clear_image (f, img);
-	    }
-	}
+          /* Create the pixmap.  */
+
+          if (x_check_image_size (0, img->width, img->height))
+            Create_Pixmap_From_Bitmap_Data (f, img, bits,
+                                            foreground, background,
+                                            non_default_colors);
+          else
+            img->pixmap = NO_PIXMAP;
+
+          if (img->pixmap)
+            success_p = 1;
+          else
+            {
+              image_error ("Unable to create pixmap for XBM image `%s'",
+                           img->spec, Qnil);
+              x_clear_image (f, img);
+            }
+        }
     }
 
   return success_p;
@@ -3088,7 +3088,7 @@ xbm_load (struct frame *f, struct image *img)
 
 
 /***********************************************************************
-			      XPM images
+                              XPM images
  ***********************************************************************/
 
 #if defined (HAVE_XPM) || defined (HAVE_NS)
@@ -3233,13 +3233,13 @@ xpm_init_color_cache (struct frame *f, XpmAttributes *attrs)
       XColor color;
 
       for (i = 0; i < attrs->numsymbols; ++i)
-	if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
-			 attrs->colorsymbols[i].value, &color))
-	  {
-	    color.pixel = lookup_rgb_color (f, color.red, color.green,
-					    color.blue);
-	    xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
-	  }
+        if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
+                         attrs->colorsymbols[i].value, &color))
+          {
+            color.pixel = lookup_rgb_color (f, color.red, color.green,
+                                            color.blue);
+            xpm_cache_color (f, attrs->colorsymbols[i].name, &color, -1);
+          }
     }
 }
 
@@ -3254,8 +3254,8 @@ xpm_free_color_cache (void)
   for (i = 0; i < XPM_COLOR_CACHE_BUCKETS; ++i)
     for (p = xpm_color_cache[i]; p; p = next)
       {
-	next = p->next;
-	xfree (p);
+        next = p->next;
+        xfree (p);
       }
 
   xfree (xpm_color_cache);
@@ -3314,10 +3314,10 @@ xpm_lookup_color (struct frame *f, char *color_name, XColor *color)
   if (p != NULL)
     *color = p->color;
   else if (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
-			color_name, color))
+                        color_name, color))
     {
       color->pixel = lookup_rgb_color (f, color->red, color->green,
-				       color->blue);
+                                       color->blue);
       p = xpm_cache_color (f, color_name, color, h);
     }
   /* You get `opaque' at least from ImageMagick converting pbm to xpm
@@ -3340,7 +3340,7 @@ xpm_lookup_color (struct frame *f, char *color_name, XColor *color)
 
 static int
 xpm_alloc_color (Display *dpy, Colormap cmap, char *color_name, XColor *color,
-		 void *closure)
+                 void *closure)
 {
   return xpm_lookup_color (closure, color_name, color);
 }
@@ -3365,9 +3365,9 @@ xpm_free_colors (Display *dpy, Colormap cmap, Pixel *pixels, int npixels, void *
 
 DEF_IMGLIB_FN (void, XpmFreeAttributes, (XpmAttributes *));
 DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer, (Display *, char *, xpm_XImage **,
-					  xpm_XImage **, XpmAttributes *));
+                                          xpm_XImage **, XpmAttributes *));
 DEF_IMGLIB_FN (int, XpmReadFileToImage, (Display *, char *, xpm_XImage **,
-				    xpm_XImage **, XpmAttributes *));
+                                    xpm_XImage **, XpmAttributes *));
 DEF_IMGLIB_FN (void, XImageFree, (xpm_XImage *));
 
 static bool
@@ -3406,9 +3406,9 @@ xpm_valid_color_symbols_p (Lisp_Object color_symbols)
     {
       Lisp_Object sym = XCAR (color_symbols);
       if (!CONSP (sym)
-	  || !STRINGP (XCAR (sym))
-	  || !STRINGP (XCDR (sym)))
-	break;
+          || !STRINGP (XCAR (sym))
+          || !STRINGP (XCDR (sym)))
+        break;
       color_symbols = XCDR (color_symbols);
     }
 
@@ -3424,12 +3424,12 @@ xpm_image_p (Lisp_Object object)
   struct image_keyword fmt[XPM_LAST];
   memcpy (fmt, xpm_format, sizeof fmt);
   return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
-	  /* Either `:file' or `:data' must be present.  */
-	  && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
-	  /* Either no `:color-symbols' or it's a list of conses
-	     whose car and cdr are strings.  */
-	  && (fmt[XPM_COLOR_SYMBOLS].count == 0
-	      || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
+          /* Either `:file' or `:data' must be present.  */
+          && fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
+          /* Either no `:color-symbols' or it's a list of conses
+             whose car and cdr are strings.  */
+          && (fmt[XPM_COLOR_SYMBOLS].count == 0
+              || xpm_valid_color_symbols_p (fmt[XPM_COLOR_SYMBOLS].value)));
 }
 
 #endif /* HAVE_XPM || HAVE_NS */
@@ -3452,7 +3452,7 @@ x_create_bitmap_from_xpm_data (struct frame *f, const char **bits)
   attrs.valuemask |= XpmColormap;
 
   rc = XpmCreatePixmapFromData (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-				(char **) bits, &bitmap, &mask, &attrs);
+                                (char **) bits, &bitmap, &mask, &attrs);
   if (rc != XpmSuccess)
     {
       XpmFreeAttributes (&attrs);
@@ -3534,7 +3534,7 @@ xpm_load (struct frame *f, struct image *img)
       /* Count number of symbols.  */
       attrs.numsymbols = 0;
       for (tail = color_symbols; CONSP (tail); tail = XCDR (tail))
-	++attrs.numsymbols;
+        ++attrs.numsymbols;
 
       /* Allocate an XpmColorSymbol array.  */
       size = attrs.numsymbols * sizeof *xpm_syms;
@@ -3544,36 +3544,36 @@ xpm_load (struct frame *f, struct image *img)
 
       /* Fill the color symbol array.  */
       for (tail = color_symbols, i = 0;
-	   CONSP (tail);
-	   ++i, tail = XCDR (tail))
-	{
-	  Lisp_Object name;
-	  Lisp_Object color;
-	  char *empty_string = (char *) "";
-
-	  if (!CONSP (XCAR (tail)))
-	    {
-	      xpm_syms[i].name = empty_string;
-	      xpm_syms[i].value = empty_string;
-	      continue;
-	    }
-	  name = XCAR (XCAR (tail));
-	  color = XCDR (XCAR (tail));
-	  if (STRINGP (name))
-	    {
-	      xpm_syms[i].name = alloca (SCHARS (name) + 1);
-	      strcpy (xpm_syms[i].name, SSDATA (name));
-	    }
-	  else
-	    xpm_syms[i].name = empty_string;
-	  if (STRINGP (color))
-	    {
-	      xpm_syms[i].value = alloca (SCHARS (color) + 1);
-	      strcpy (xpm_syms[i].value, SSDATA (color));
-	    }
-	  else
-	    xpm_syms[i].value = empty_string;
-	}
+           CONSP (tail);
+           ++i, tail = XCDR (tail))
+        {
+          Lisp_Object name;
+          Lisp_Object color;
+          char *empty_string = (char *) "";
+
+          if (!CONSP (XCAR (tail)))
+            {
+              xpm_syms[i].name = empty_string;
+              xpm_syms[i].value = empty_string;
+              continue;
+            }
+          name = XCAR (XCAR (tail));
+          color = XCDR (XCAR (tail));
+          if (STRINGP (name))
+            {
+              xpm_syms[i].name = alloca (SCHARS (name) + 1);
+              strcpy (xpm_syms[i].name, SSDATA (name));
+            }
+          else
+            xpm_syms[i].name = empty_string;
+          if (STRINGP (color))
+            {
+              xpm_syms[i].value = alloca (SCHARS (color) + 1);
+              strcpy (xpm_syms[i].value, SSDATA (color));
+            }
+          else
+            xpm_syms[i].value = empty_string;
+        }
     }
 
   /* Create a pixmap for the image, either from a file, or from a
@@ -3596,53 +3596,53 @@ xpm_load (struct frame *f, struct image *img)
     {
       Lisp_Object file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
 #ifdef ALLOC_XPM_COLORS
-	  xpm_free_color_cache ();
+          xpm_free_color_cache ();
 #endif
-	  return 0;
-	}
+          return 0;
+        }
 
 #ifdef HAVE_NTGUI
 #ifdef WINDOWSNT
       /* FILE is encoded in UTF-8, but image libraries on Windows
-	 support neither UTF-8 nor UTF-16 encoded file names.  So we
-	 need to re-encode it in ANSI.  */
+         support neither UTF-8 nor UTF-16 encoded file names.  So we
+         need to re-encode it in ANSI.  */
       file = ansi_encode_filename (file);
 #endif
       /* XpmReadFileToPixmap is not available in the Windows port of
-	 libxpm.  But XpmReadFileToImage almost does what we want.  */
+         libxpm.  But XpmReadFileToImage almost does what we want.  */
       rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
-				  &xpm_image, &xpm_mask,
-				  &attrs);
+                                  &xpm_image, &xpm_mask,
+                                  &attrs);
 #else
       rc = XpmReadFileToImage (FRAME_X_DISPLAY (f), SSDATA (file),
-			       &img->ximg, &img->mask_img,
-			       &attrs);
+                               &img->ximg, &img->mask_img,
+                               &attrs);
 #endif /* HAVE_NTGUI */
     }
   else
     {
       Lisp_Object buffer = image_spec_value (img->spec, QCdata, NULL);
       if (!STRINGP (buffer))
-	{
-	  image_error ("Invalid image data `%s'", buffer, Qnil);
+        {
+          image_error ("Invalid image data `%s'", buffer, Qnil);
 #ifdef ALLOC_XPM_COLORS
-	  xpm_free_color_cache ();
+          xpm_free_color_cache ();
 #endif
-	  return 0;
-	}
+          return 0;
+        }
 #ifdef HAVE_NTGUI
       /* XpmCreatePixmapFromBuffer is not available in the Windows port
-	 of libxpm.  But XpmCreateImageFromBuffer almost does what we want.  */
+         of libxpm.  But XpmCreateImageFromBuffer almost does what we want.  */
       rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
-					&xpm_image, &xpm_mask,
-					&attrs);
+                                        &xpm_image, &xpm_mask,
+                                        &attrs);
 #else
       rc = XpmCreateImageFromBuffer (FRAME_X_DISPLAY (f), SSDATA (buffer),
-				     &img->ximg, &img->mask_img,
-				     &attrs);
+                                     &img->ximg, &img->mask_img,
+                                     &attrs);
 #endif /* HAVE_NTGUI */
     }
 
@@ -3650,25 +3650,25 @@ xpm_load (struct frame *f, struct image *img)
   if (rc == XpmSuccess)
     {
       img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-				   img->ximg->width, img->ximg->height,
-				   img->ximg->depth);
+                                   img->ximg->width, img->ximg->height,
+                                   img->ximg->depth);
       if (img->pixmap == NO_PIXMAP)
-	{
-	  x_clear_image (f, img);
-	  rc = XpmNoMemory;
-	}
+        {
+          x_clear_image (f, img);
+          rc = XpmNoMemory;
+        }
       else if (img->mask_img)
-	{
-	  img->mask = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-				     img->mask_img->width,
-				     img->mask_img->height,
-				     img->mask_img->depth);
-	  if (img->mask == NO_PIXMAP)
-	    {
-	      x_clear_image (f, img);
-	      rc = XpmNoMemory;
-	    }
-	}
+        {
+          img->mask = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                                     img->mask_img->width,
+                                     img->mask_img->height,
+                                     img->mask_img->depth);
+          if (img->mask == NO_PIXMAP)
+            {
+              x_clear_image (f, img);
+              rc = XpmNoMemory;
+            }
+        }
     }
 #endif
 
@@ -3681,29 +3681,29 @@ xpm_load (struct frame *f, struct image *img)
 
 #ifdef HAVE_NTGUI
       /* W32 XPM uses XImage to wrap what W32 Emacs calls a Pixmap,
-	 plus some duplicate attributes.  */
+         plus some duplicate attributes.  */
       if (xpm_image && xpm_image->bitmap)
-	{
-	  img->pixmap = xpm_image->bitmap;
-	  /* XImageFree in libXpm frees XImage struct without destroying
-	     the bitmap, which is what we want.  */
-	  fn_XImageFree (xpm_image);
-	}
+        {
+          img->pixmap = xpm_image->bitmap;
+          /* XImageFree in libXpm frees XImage struct without destroying
+             the bitmap, which is what we want.  */
+          fn_XImageFree (xpm_image);
+        }
       if (xpm_mask && xpm_mask->bitmap)
-	{
-	  /* The mask appears to be inverted compared with what we expect.
-	     TODO: invert our expectations.  See other places where we
-	     have to invert bits because our idea of masks is backwards.  */
-	  HGDIOBJ old_obj;
-	  old_obj = SelectObject (hdc, xpm_mask->bitmap);
-
-	  PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
-	  SelectObject (hdc, old_obj);
-
-	  img->mask = xpm_mask->bitmap;
-	  fn_XImageFree (xpm_mask);
-	  DeleteDC (hdc);
-	}
+        {
+          /* The mask appears to be inverted compared with what we expect.
+             TODO: invert our expectations.  See other places where we
+             have to invert bits because our idea of masks is backwards.  */
+          HGDIOBJ old_obj;
+          old_obj = SelectObject (hdc, xpm_mask->bitmap);
+
+          PatBlt (hdc, 0, 0, xpm_mask->width, xpm_mask->height, DSTINVERT);
+          SelectObject (hdc, old_obj);
+
+          img->mask = xpm_mask->bitmap;
+          fn_XImageFree (xpm_mask);
+          DeleteDC (hdc);
+        }
 
       DeleteDC (hdc);
 #endif /* HAVE_NTGUI */
@@ -3712,12 +3712,12 @@ xpm_load (struct frame *f, struct image *img)
       img->colors = xnmalloc (attrs.nalloc_pixels, sizeof *img->colors);
       img->ncolors = attrs.nalloc_pixels;
       for (i = 0; i < attrs.nalloc_pixels; ++i)
-	{
-	  img->colors[i] = attrs.alloc_pixels[i];
+        {
+          img->colors[i] = attrs.alloc_pixels[i];
 #ifdef DEBUG_X_COLORS
-	  register_color (img->colors[i]);
+          register_color (img->colors[i]);
 #endif
-	}
+        }
 #endif /* not ALLOC_XPM_COLORS */
 
       img->width = attrs.width;
@@ -3735,9 +3735,9 @@ xpm_load (struct frame *f, struct image *img)
       /* Maybe fill in the background field while we have ximg handy.  */
       IMAGE_BACKGROUND (img, f, img->ximg);
       if (img->mask_img)
-	/* Fill in the background_transparent field while we have the
-	   mask handy.  */
-	image_background_transparent (img, f, img->mask_img);
+        /* Fill in the background_transparent field while we have the
+           mask handy.  */
+        image_background_transparent (img, f, img->mask_img);
 #endif
     }
   else
@@ -3747,27 +3747,27 @@ xpm_load (struct frame *f, struct image *img)
 #endif /* HAVE_NTGUI */
 
       switch (rc)
-	{
-	case XpmOpenFailed:
-	  image_error ("Error opening XPM file (%s)", img->spec, Qnil);
-	  break;
+        {
+        case XpmOpenFailed:
+          image_error ("Error opening XPM file (%s)", img->spec, Qnil);
+          break;
 
-	case XpmFileInvalid:
-	  image_error ("Invalid XPM file (%s)", img->spec, Qnil);
-	  break;
+        case XpmFileInvalid:
+          image_error ("Invalid XPM file (%s)", img->spec, Qnil);
+          break;
 
-	case XpmNoMemory:
-	  image_error ("Out of memory (%s)", img->spec, Qnil);
-	  break;
+        case XpmNoMemory:
+          image_error ("Out of memory (%s)", img->spec, Qnil);
+          break;
 
-	case XpmColorFailed:
-	  image_error ("Color allocation error (%s)", img->spec, Qnil);
-	  break;
+        case XpmColorFailed:
+          image_error ("Color allocation error (%s)", img->spec, Qnil);
+          break;
 
-	default:
-	  image_error ("Unknown error (%s)", img->spec, Qnil);
-	  break;
-	}
+        default:
+          image_error ("Unknown error (%s)", img->spec, Qnil);
+          break;
+        }
     }
 
 #ifdef ALLOC_XPM_COLORS
@@ -3820,50 +3820,50 @@ xpm_scan (const unsigned char **s,
     {
       /* Skip white-space.  */
       while (*s < end && (c = *(*s)++, c_isspace (c)))
-	;
+        ;
 
       /* gnus-pointer.xpm uses '-' in its identifier.
-	 sb-dir-plus.xpm uses '+' in its identifier.  */
+         sb-dir-plus.xpm uses '+' in its identifier.  */
       if (c_isalpha (c) || c == '_' || c == '-' || c == '+')
-	{
-	  *beg = *s - 1;
-	  while (*s < end
-		 && (c = **s, c_isalnum (c)
-		     || c == '_' || c == '-' || c == '+'))
-	      ++*s;
-	  *len = *s - *beg;
-	  return XPM_TK_IDENT;
-	}
+        {
+          *beg = *s - 1;
+          while (*s < end
+                 && (c = **s, c_isalnum (c)
+                     || c == '_' || c == '-' || c == '+'))
+              ++*s;
+          *len = *s - *beg;
+          return XPM_TK_IDENT;
+        }
       else if (c == '"')
-	{
-	  *beg = *s;
-	  while (*s < end && **s != '"')
-	    ++*s;
-	  *len = *s - *beg;
-	  if (*s < end)
-	    ++*s;
-	  return XPM_TK_STRING;
-	}
+        {
+          *beg = *s;
+          while (*s < end && **s != '"')
+            ++*s;
+          *len = *s - *beg;
+          if (*s < end)
+            ++*s;
+          return XPM_TK_STRING;
+        }
       else if (c == '/')
-	{
-	  if (*s < end && **s == '*')
-	    {
-	      /* C-style comment.  */
-	      ++*s;
-	      do
-		{
-		  while (*s < end && *(*s)++ != '*')
-		    ;
-		}
-	      while (*s < end && **s != '/');
-	      if (*s < end)
-		++*s;
-	    }
-	  else
-	    return c;
-	}
+        {
+          if (*s < end && **s == '*')
+            {
+              /* C-style comment.  */
+              ++*s;
+              do
+                {
+                  while (*s < end && *(*s)++ != '*')
+                    ;
+                }
+              while (*s < end && **s != '/');
+              if (*s < end)
+                ++*s;
+            }
+          else
+            return c;
+        }
       else
-	return c;
+        return c;
     }
 
   return XPM_TK_EOF;
@@ -3919,9 +3919,9 @@ xpm_make_color_table_h (void (**put_func) (Lisp_Object,
   *put_func = xpm_put_color_table_h;
   *get_func = xpm_get_color_table_h;
   return make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE),
-			  make_float (DEFAULT_REHASH_SIZE),
-			  make_float (DEFAULT_REHASH_THRESHOLD),
-			  Qnil);
+                          make_float (DEFAULT_REHASH_SIZE),
+                          make_float (DEFAULT_REHASH_THRESHOLD),
+                          Qnil);
 }
 
 static void
@@ -3996,8 +3996,8 @@ xpm_load_image (struct frame *f,
 #define expect(TOKEN)		\
   do				\
     {				\
-      if (LA1 != (TOKEN)) 	\
-	goto failure;		\
+      if (LA1 != (TOKEN))       \
+        goto failure;		\
       match ();			\
     }				\
   while (0)
@@ -4027,7 +4027,7 @@ xpm_load_image (struct frame *f,
   memcpy (buffer, beg, len);
   buffer[len] = '\0';
   if (sscanf (buffer, "%d %d %d %d", &width, &height,
-	      &num_colors, &chars_per_pixel) != 4
+              &num_colors, &chars_per_pixel) != 4
       || width <= 0 || height <= 0
       || num_colors <= 0 || chars_per_pixel <= 0)
     goto failure;
@@ -4041,7 +4041,7 @@ xpm_load_image (struct frame *f,
   if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0)
 #ifndef HAVE_NS
       || !image_create_x_image_and_pixmap (f, img, width, height, 1,
-					   &mask_img, 1)
+                                           &mask_img, 1)
 #endif
       )
     {
@@ -4056,17 +4056,17 @@ xpm_load_image (struct frame *f,
     best_key = XPM_COLOR_KEY_C;
   else if (!NILP (Fx_display_grayscale_p (frame)))
     best_key = (XFASTINT (Fx_display_planes (frame)) > 2
-		? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
+                ? XPM_COLOR_KEY_G : XPM_COLOR_KEY_G4);
   else
     best_key = XPM_COLOR_KEY_M;
 
   color_symbols = image_spec_value (img->spec, QCcolor_symbols, NULL);
   if (chars_per_pixel == 1)
     color_table = xpm_make_color_table_v (&put_color_table,
-					  &get_color_table);
+                                          &get_color_table);
   else
     color_table = xpm_make_color_table_h (&put_color_table,
-					  &get_color_table);
+                                          &get_color_table);
 
   while (num_colors-- > 0)
     {
@@ -4077,67 +4077,67 @@ xpm_load_image (struct frame *f,
 
       expect (XPM_TK_STRING);
       if (len <= chars_per_pixel || len >= BUFSIZ + chars_per_pixel)
-	goto failure;
+        goto failure;
       memcpy (buffer, beg + chars_per_pixel, len - chars_per_pixel);
       buffer[len - chars_per_pixel] = '\0';
 
       str = strtok (buffer, " \t");
       if (str == NULL)
-	goto failure;
+        goto failure;
       key = xpm_str_to_color_key (str);
       if (key < 0)
-	goto failure;
+        goto failure;
       do
-	{
-	  color = strtok (NULL, " \t");
-	  if (color == NULL)
-	    goto failure;
-
-	  while ((str = strtok (NULL, " \t")) != NULL)
-	    {
-	      next_key = xpm_str_to_color_key (str);
-	      if (next_key >= 0)
-		break;
-	      color[strlen (color)] = ' ';
-	    }
-
-	  if (key == XPM_COLOR_KEY_S)
-	    {
-	      if (NILP (symbol_color))
-		symbol_color = build_string (color);
-	    }
-	  else if (max_key < key && key <= best_key)
-	    {
-	      max_key = key;
-	      max_color = color;
-	    }
-	  key = next_key;
-	}
+        {
+          color = strtok (NULL, " \t");
+          if (color == NULL)
+            goto failure;
+
+          while ((str = strtok (NULL, " \t")) != NULL)
+            {
+              next_key = xpm_str_to_color_key (str);
+              if (next_key >= 0)
+                break;
+              color[strlen (color)] = ' ';
+            }
+
+          if (key == XPM_COLOR_KEY_S)
+            {
+              if (NILP (symbol_color))
+                symbol_color = build_string (color);
+            }
+          else if (max_key < key && key <= best_key)
+            {
+              max_key = key;
+              max_color = color;
+            }
+          key = next_key;
+        }
       while (str);
 
       color_val = Qnil;
       if (!NILP (color_symbols) && !NILP (symbol_color))
-	{
-	  Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
-
-	  if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
-	    {
-	      if (xstrcasecmp (SSDATA (XCDR (specified_color)), "None") == 0)
-		color_val = Qt;
-	      else if (x_defined_color (f, SSDATA (XCDR (specified_color)),
-					&cdef, 0))
-		color_val = make_number (cdef.pixel);
-	    }
-	}
+        {
+          Lisp_Object specified_color = Fassoc (symbol_color, color_symbols);
+
+          if (CONSP (specified_color) && STRINGP (XCDR (specified_color)))
+            {
+              if (xstrcasecmp (SSDATA (XCDR (specified_color)), "None") == 0)
+                color_val = Qt;
+              else if (x_defined_color (f, SSDATA (XCDR (specified_color)),
+                                        &cdef, 0))
+                color_val = make_number (cdef.pixel);
+            }
+        }
       if (NILP (color_val) && max_key > 0)
-	{
-	  if (xstrcasecmp (max_color, "None") == 0)
-	    color_val = Qt;
-	  else if (x_defined_color (f, max_color, &cdef, 0))
-	    color_val = make_number (cdef.pixel);
-	}
+        {
+          if (xstrcasecmp (max_color, "None") == 0)
+            color_val = Qt;
+          else if (x_defined_color (f, max_color, &cdef, 0))
+            color_val = make_number (cdef.pixel);
+        }
       if (!NILP (color_val))
-	(*put_color_table) (color_table, beg, chars_per_pixel, color_val);
+        (*put_color_table) (color_table, beg, chars_per_pixel, color_val);
 
       expect (',');
     }
@@ -4147,26 +4147,26 @@ xpm_load_image (struct frame *f,
       expect (XPM_TK_STRING);
       str = beg;
       if (len < width * chars_per_pixel)
-	goto failure;
+        goto failure;
       for (x = 0; x < width; x++, str += chars_per_pixel)
-	{
-	  Lisp_Object color_val =
-	    (*get_color_table) (color_table, str, chars_per_pixel);
+        {
+          Lisp_Object color_val =
+            (*get_color_table) (color_table, str, chars_per_pixel);
 
-	  XPutPixel (ximg, x, y,
-		     (INTEGERP (color_val) ? XINT (color_val)
-		      : FRAME_FOREGROUND_PIXEL (f)));
+          XPutPixel (ximg, x, y,
+                     (INTEGERP (color_val) ? XINT (color_val)
+                      : FRAME_FOREGROUND_PIXEL (f)));
 #ifndef HAVE_NS
-	  XPutPixel (mask_img, x, y,
-		     (!EQ (color_val, Qt) ? PIX_MASK_DRAW
-		      : (have_mask = true, PIX_MASK_RETAIN)));
+          XPutPixel (mask_img, x, y,
+                     (!EQ (color_val, Qt) ? PIX_MASK_DRAW
+                      : (have_mask = true, PIX_MASK_RETAIN)));
 #else
           if (EQ (color_val, Qt))
             ns_set_alpha (ximg, x, y, 0);
 #endif
-	}
+        }
       if (y + 1 < height)
-	expect (',');
+        expect (',');
     }
 
   img->width = width;
@@ -4181,7 +4181,7 @@ xpm_load_image (struct frame *f,
   if (have_mask)
     {
       /* Fill in the background_transparent field while we have the
-	 mask handy.  */
+         mask handy.  */
       image_background_transparent (img, f, mask_img);
 
       image_put_x_image (f, img, mask_img, 1);
@@ -4223,17 +4223,17 @@ xpm_load (struct frame *f,
 
       file = x_find_image_file (file_name);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", file_name, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", file_name, Qnil);
+          return 0;
+        }
 
       contents = slurp_file (SSDATA (file), &size);
       if (contents == NULL)
-	{
-	  image_error ("Error loading XPM image `%s'", img->spec, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Error loading XPM image `%s'", img->spec, Qnil);
+          return 0;
+        }
 
       success_p = xpm_load_image (f, img, contents, contents + size);
       xfree (contents);
@@ -4244,12 +4244,12 @@ xpm_load (struct frame *f,
 
       data = image_spec_value (img->spec, QCdata, NULL);
       if (!STRINGP (data))
-	{
-	  image_error ("Invalid image data `%s'", data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       success_p = xpm_load_image (f, img, SDATA (data),
-				  SDATA (data) + SBYTES (data));
+                                  SDATA (data) + SBYTES (data));
     }
 
   return success_p;
@@ -4260,7 +4260,7 @@ xpm_load (struct frame *f,
 
 
 /***********************************************************************
-			     Color table
+                             Color table
  ***********************************************************************/
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -4295,7 +4295,7 @@ enum
 {
   ct_colors_allocated_max =
     min (INT_MAX,
-	 min (PTRDIFF_MAX, SIZE_MAX) / sizeof (unsigned long))
+         min (PTRDIFF_MAX, SIZE_MAX) / sizeof (unsigned long))
 };
 
 /* Initialize the color table.  */
@@ -4320,8 +4320,8 @@ free_color_table (void)
   for (i = 0; i < CT_SIZE; ++i)
     for (p = ct_table[i]; p; p = next)
       {
-	next = p->next;
-	xfree (p);
+        next = p->next;
+        xfree (p);
       }
 
   xfree (ct_table);
@@ -4353,16 +4353,16 @@ lookup_rgb_color (struct frame *f, int r, int g, int b)
 
       /* Apply gamma-correction like normal color allocation does.  */
       if (f->gamma)
-	{
-	  XColor color;
-	  color.red = r, color.green = g, color.blue = b;
-	  gamma_correct (f, &color);
-	  r = color.red, g = color.green, b = color.blue;
-	}
+        {
+          XColor color;
+          color.red = r, color.green = g, color.blue = b;
+          gamma_correct (f, &color);
+          r = color.red, g = color.green, b = color.blue;
+        }
 
       /* Scale down RGB values to the visual's bits per RGB, and shift
-	 them to the right position in the pixel color.  Note that the
-	 original RGB values are 16-bit values, as usual in X.  */
+         them to the right position in the pixel color.  Note that the
+         original RGB values are 16-bit values, as usual in X.  */
       pr = (r >> (16 - dpyinfo->red_bits))   << dpyinfo->red_offset;
       pg = (g >> (16 - dpyinfo->green_bits)) << dpyinfo->green_offset;
       pb = (b >> (16 - dpyinfo->blue_bits))  << dpyinfo->blue_offset;
@@ -4387,7 +4387,7 @@ lookup_rgb_color (struct frame *f, int r, int g, int b)
 #endif
 
       if (ct_colors_allocated_max <= ct_colors_allocated)
-	return FRAME_FOREGROUND_PIXEL (f);
+        return FRAME_FOREGROUND_PIXEL (f);
 
 #ifdef HAVE_X_WINDOWS
       color.red = r;
@@ -4397,18 +4397,18 @@ lookup_rgb_color (struct frame *f, int r, int g, int b)
       cmap = FRAME_X_COLORMAP (f);
       rc = x_alloc_nearest_color (f, cmap, &color);
       if (rc)
-	{
-	  ++ct_colors_allocated;
-	  p = xmalloc (sizeof *p);
-	  p->r = r;
-	  p->g = g;
-	  p->b = b;
-	  p->pixel = color.pixel;
-	  p->next = ct_table[i];
-	  ct_table[i] = p;
-	}
+        {
+          ++ct_colors_allocated;
+          p = xmalloc (sizeof *p);
+          p->r = r;
+          p->g = g;
+          p->b = b;
+          p->pixel = color.pixel;
+          p->next = ct_table[i];
+          ct_table[i] = p;
+        }
       else
-	return FRAME_FOREGROUND_PIXEL (f);
+        return FRAME_FOREGROUND_PIXEL (f);
 
 #else
 #ifdef HAVE_NTGUI
@@ -4452,7 +4452,7 @@ lookup_pixel_color (struct frame *f, unsigned long pixel)
       bool rc;
 
       if (ct_colors_allocated_max <= ct_colors_allocated)
-	return FRAME_FOREGROUND_PIXEL (f);
+        return FRAME_FOREGROUND_PIXEL (f);
 
 #ifdef HAVE_X_WINDOWS
       cmap = FRAME_X_COLORMAP (f);
@@ -4469,19 +4469,19 @@ lookup_pixel_color (struct frame *f, unsigned long pixel)
 #endif /* HAVE_X_WINDOWS */
 
       if (rc)
-	{
-	  ++ct_colors_allocated;
-
-	  p = xmalloc (sizeof *p);
-	  p->r = color.red;
-	  p->g = color.green;
-	  p->b = color.blue;
-	  p->pixel = pixel;
-	  p->next = ct_table[i];
-	  ct_table[i] = p;
-	}
+        {
+          ++ct_colors_allocated;
+
+          p = xmalloc (sizeof *p);
+          p->r = color.red;
+          p->g = color.green;
+          p->b = color.blue;
+          p->pixel = pixel;
+          p->next = ct_table[i];
+          ct_table[i] = p;
+        }
       else
-	return FRAME_FOREGROUND_PIXEL (f);
+        return FRAME_FOREGROUND_PIXEL (f);
     }
   return p->pixel;
 }
@@ -4508,8 +4508,8 @@ colors_in_color_table (int *n)
       *n = ct_colors_allocated;
 
       for (i = j = 0; i < CT_SIZE; ++i)
-	for (p = ct_table[i]; p; p = p->next)
-	  colors[j++] = p->pixel;
+        for (p = ct_table[i]; p; p = p->next)
+          colors[j++] = p->pixel;
     }
 
   return colors;
@@ -4540,7 +4540,7 @@ init_color_table (void)
 
 
 /***********************************************************************
-			      Algorithms
+                              Algorithms
  ***********************************************************************/
 
 /* Edge detection matrices for different edge-detection
@@ -4548,14 +4548,14 @@ init_color_table (void)
 
 static int emboss_matrix[9] = {
    /* x - 1	x	x + 1  */
-        2,     -1,  	  0,		/* y - 1 */
+        2,     -1,        0,		/* y - 1 */
        -1,      0,        1,		/* y     */
         0,      1,       -2		/* y + 1 */
 };
 
 static int laplace_matrix[9] = {
    /* x - 1	x	x + 1  */
-        1,      0,  	  0,		/* y - 1 */
+        1,      0,        0,		/* y - 1 */
         0,      0,        0,		/* y     */
         0,      0,       -1		/* y + 1 */
 };
@@ -4597,23 +4597,23 @@ x_to_xcolors (struct frame *f, struct image *img, bool rgb_p)
 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
       XColor *row = p;
       for (x = 0; x < img->width; ++x, ++p)
-	p->pixel = GET_PIXEL (ximg, x, y);
+        p->pixel = GET_PIXEL (ximg, x, y);
       if (rgb_p)
-	x_query_colors (f, row, img->width);
+        x_query_colors (f, row, img->width);
 
 #else
 
       for (x = 0; x < img->width; ++x, ++p)
-	{
-	  /* W32_TODO: palette support needed here?  */
-	  p->pixel = GET_PIXEL (ximg, x, y);
-	  if (rgb_p)
-	    {
-	      p->red = RED16_FROM_ULONG (p->pixel);
-	      p->green = GREEN16_FROM_ULONG (p->pixel);
-	      p->blue = BLUE16_FROM_ULONG (p->pixel);
-	    }
-	}
+        {
+          /* W32_TODO: palette support needed here?  */
+          p->pixel = GET_PIXEL (ximg, x, y);
+          if (rgb_p)
+            {
+              p->red = RED16_FROM_ULONG (p->pixel);
+              p->green = GREEN16_FROM_ULONG (p->pixel);
+              p->blue = BLUE16_FROM_ULONG (p->pixel);
+            }
+        }
 #endif /* HAVE_X_WINDOWS */
     }
 
@@ -4640,7 +4640,7 @@ XPutPixel (XImagePtr ximg, int x, int y, COLORREF color)
       int rowbytes = width * 3;
       /* Ensure scanlines are aligned on 4 byte boundaries.  */
       if (rowbytes % 4)
-	rowbytes += 4 - (rowbytes % 4);
+        rowbytes += 4 - (rowbytes % 4);
 
       pixel = ximg->data + y * rowbytes + x * 3;
       /* Windows bitmaps are in BGR order.  */
@@ -4654,13 +4654,13 @@ XPutPixel (XImagePtr ximg, int x, int y, COLORREF color)
       int rowbytes = width / 8;
       /* Ensure scanlines are aligned on 4 byte boundaries.  */
       if (rowbytes % 4)
-	rowbytes += 4 - (rowbytes % 4);
+        rowbytes += 4 - (rowbytes % 4);
       pixel = ximg->data + y * rowbytes + x / 8;
       /* Filter out palette info.  */
       if (color & 0x00ffffff)
-	*pixel = *pixel | (1 << x % 8);
+        *pixel = *pixel | (1 << x % 8);
       else
-	*pixel = *pixel & ~(1 << x % 8);
+        *pixel = *pixel & ~(1 << x % 8);
     }
   else
     image_error ("XPutPixel: palette image not supported", Qnil, Qnil);
@@ -4683,14 +4683,14 @@ x_from_xcolors (struct frame *f, struct image *img, XColor *colors)
 
   x_clear_image_1 (f, img, CLEAR_IMAGE_PIXMAP | CLEAR_IMAGE_COLORS);
   image_create_x_image_and_pixmap (f, img, img->width, img->height, 0,
-				   &oimg, 0);
+                                   &oimg, 0);
   p = colors;
   for (y = 0; y < img->height; ++y)
     for (x = 0; x < img->width; ++x, ++p)
       {
-	unsigned long pixel;
-	pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
-	XPutPixel (oimg, x, y, pixel);
+        unsigned long pixel;
+        pixel = lookup_rgb_color (f, p->red, p->green, p->blue);
+        XPutPixel (oimg, x, y, pixel);
       }
 
   xfree (colors);
@@ -4748,25 +4748,25 @@ x_detect_edges (struct frame *f, struct image *img, int *matrix, int color_adjus
       p = COLOR (new, 1, y);
 
       for (x = 1; x < img->width - 1; ++x, ++p)
-	{
-	  int r, g, b, yy, xx;
-
-	  r = g = b = i = 0;
-	  for (yy = y - 1; yy < y + 2; ++yy)
-	    for (xx = x - 1; xx < x + 2; ++xx, ++i)
-	      if (matrix[i])
-	        {
-	          XColor *t = COLOR (colors, xx, yy);
-		  r += matrix[i] * t->red;
-		  g += matrix[i] * t->green;
-		  b += matrix[i] * t->blue;
-		}
-
-	  r = (r / sum + color_adjust) & 0xffff;
-	  g = (g / sum + color_adjust) & 0xffff;
-	  b = (b / sum + color_adjust) & 0xffff;
-	  p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
-	}
+        {
+          int r, g, b, yy, xx;
+
+          r = g = b = i = 0;
+          for (yy = y - 1; yy < y + 2; ++yy)
+            for (xx = x - 1; xx < x + 2; ++xx, ++i)
+              if (matrix[i])
+                {
+                  XColor *t = COLOR (colors, xx, yy);
+                  r += matrix[i] * t->red;
+                  g += matrix[i] * t->green;
+                  b += matrix[i] * t->blue;
+                }
+
+          r = (r / sum + color_adjust) & 0xffff;
+          g = (g / sum + color_adjust) & 0xffff;
+          b = (b / sum + color_adjust) & 0xffff;
+          p->red = p->green = p->blue = COLOR_INTENSITY (r, g, b);
+        }
     }
 
   xfree (colors);
@@ -4810,7 +4810,7 @@ x_laplace (struct frame *f, struct image *img)
 
 static void
 x_edge_detection (struct frame *f, struct image *img, Lisp_Object matrix,
-		  Lisp_Object color_adjust)
+                  Lisp_Object color_adjust)
 {
   int i = 0;
   int trans[9];
@@ -4818,14 +4818,14 @@ x_edge_detection (struct frame *f, struct image *img, Lisp_Object matrix,
   if (CONSP (matrix))
     {
       for (i = 0;
-	   i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
-	   ++i, matrix = XCDR (matrix))
-	trans[i] = XFLOATINT (XCAR (matrix));
+           i < 9 && CONSP (matrix) && NUMBERP (XCAR (matrix));
+           ++i, matrix = XCDR (matrix))
+        trans[i] = XFLOATINT (XCAR (matrix));
     }
   else if (VECTORP (matrix) && ASIZE (matrix) >= 9)
     {
       for (i = 0; i < 9 && NUMBERP (AREF (matrix, i)); ++i)
-	trans[i] = XFLOATINT (AREF (matrix, i));
+        trans[i] = XFLOATINT (AREF (matrix, i));
     }
 
   if (NILP (color_adjust))
@@ -4851,21 +4851,21 @@ x_disable_image (struct frame *f, struct image *img)
   if (n_planes >= 2)
     {
       /* Color (or grayscale).  Convert to gray, and equalize.  Just
-	 drawing such images with a stipple can look very odd, so
-	 we're using this method instead.  */
+         drawing such images with a stipple can look very odd, so
+         we're using this method instead.  */
       XColor *colors = x_to_xcolors (f, img, 1);
       XColor *p, *end;
       const int h = 15000;
       const int l = 30000;
 
       for (p = colors, end = colors + img->width * img->height;
-	   p < end;
-	   ++p)
-	{
-	  int i = COLOR_INTENSITY (p->red, p->green, p->blue);
-	  int i2 = (0xffff - h - l) * i / 0xffff + l;
-	  p->red = p->green = p->blue = i2;
-	}
+           p < end;
+           ++p)
+        {
+          int i = COLOR_INTENSITY (p->red, p->green, p->blue);
+          int i2 = (0xffff - h - l) * i / 0xffff + l;
+          p->red = p->green = p->blue = i2;
+        }
 
       x_from_xcolors (f, img, colors);
     }
@@ -4886,21 +4886,21 @@ x_disable_image (struct frame *f, struct image *img)
       gc = XCreateGC (dpy, img->pixmap, 0, NULL);
       XSetForeground (dpy, gc, BLACK_PIX_DEFAULT (f));
       XDrawLine (dpy, img->pixmap, gc, 0, 0,
-		 img->width - 1, img->height - 1);
+                 img->width - 1, img->height - 1);
       XDrawLine (dpy, img->pixmap, gc, 0, img->height - 1,
-		 img->width - 1, 0);
+                 img->width - 1, 0);
       XFreeGC (dpy, gc);
 
       if (img->mask)
-	{
-	  gc = XCreateGC (dpy, img->mask, 0, NULL);
-	  XSetForeground (dpy, gc, MaskForeground (f));
-	  XDrawLine (dpy, img->mask, gc, 0, 0,
-		     img->width - 1, img->height - 1);
-	  XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
-		     img->width - 1, 0);
-	  XFreeGC (dpy, gc);
-	}
+        {
+          gc = XCreateGC (dpy, img->mask, 0, NULL);
+          XSetForeground (dpy, gc, MaskForeground (f));
+          XDrawLine (dpy, img->mask, gc, 0, 0,
+                     img->width - 1, img->height - 1);
+          XDrawLine (dpy, img->mask, gc, 0, img->height - 1,
+                     img->width - 1, 0);
+          XFreeGC (dpy, gc);
+        }
 #endif /* !HAVE_NS */
 #else
       HDC hdc, bmpdc;
@@ -4919,14 +4919,14 @@ x_disable_image (struct frame *f, struct image *img)
       LineTo (bmpdc, img->width - 1, 0);
 
       if (img->mask)
-	{
-	  SelectObject (bmpdc, img->mask);
-	  SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
-	  MoveToEx (bmpdc, 0, 0, NULL);
-	  LineTo (bmpdc, img->width - 1, img->height - 1);
-	  MoveToEx (bmpdc, 0, img->height - 1, NULL);
-	  LineTo (bmpdc, img->width - 1, 0);
-	}
+        {
+          SelectObject (bmpdc, img->mask);
+          SetTextColor (bmpdc, WHITE_PIX_DEFAULT (f));
+          MoveToEx (bmpdc, 0, 0, NULL);
+          LineTo (bmpdc, img->width - 1, img->height - 1);
+          MoveToEx (bmpdc, 0, img->height - 1, NULL);
+          LineTo (bmpdc, img->width - 1, 0);
+        }
       SelectObject (bmpdc, prev);
       DeleteDC (bmpdc);
 #endif /* HAVE_NTGUI */
@@ -4963,7 +4963,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
 #ifndef HAVE_NS
   /* Create an image and pixmap serving as mask.  */
   if (! image_create_x_image_and_pixmap (f, img, img->width, img->height, 1,
-					 &mask_img, 1))
+                                         &mask_img, 1))
     return;
 #endif /* !HAVE_NS */
 #else
@@ -4984,22 +4984,22 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
       int rgb[3], i;
 
       for (i = 0; i < 3 && CONSP (how) && NATNUMP (XCAR (how)); ++i)
-	{
-	  rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
-	  how = XCDR (how);
-	}
+        {
+          rgb[i] = XFASTINT (XCAR (how)) & 0xffff;
+          how = XCDR (how);
+        }
 
       if (i == 3 && NILP (how))
-	{
-	  char color_name[30];
-	  sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
-	  bg = (
+        {
+          char color_name[30];
+          sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
+          bg = (
 #ifdef HAVE_NTGUI
-		0x00ffffff & /* Filter out palette info.  */
+                0x00ffffff & /* Filter out palette info.  */
 #endif /* HAVE_NTGUI */
-		x_alloc_image_color (f, img, build_string (color_name), 0));
-	  use_img_background = 0;
-	}
+                x_alloc_image_color (f, img, build_string (color_name), 0));
+          use_img_background = 0;
+        }
     }
 
   if (use_img_background)
@@ -5012,7 +5012,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
     for (x = 0; x < img->width; ++x)
 #ifndef HAVE_NS
       XPutPixel (mask_img, x, y, (XGetPixel (ximg, x, y) != bg
-				  ? PIX_MASK_DRAW : PIX_MASK_RETAIN));
+                                  ? PIX_MASK_DRAW : PIX_MASK_RETAIN));
 #else
       if (XGetPixel (ximg, x, y) == bg)
         ns_set_alpha (ximg, x, y, 0);
@@ -5028,14 +5028,14 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
   for (y = 0; y < img->height; ++y)
     for (x = 0; x < img->width; ++x)
       {
-	COLORREF p = GetPixel (ximg, x, y);
-	if (p != bg)
-	  mask_img[y * row_width + x / 8] |= 1 << (x % 8);
+        COLORREF p = GetPixel (ximg, x, y);
+        if (p != bg)
+          mask_img[y * row_width + x / 8] |= 1 << (x % 8);
       }
 
   /* Create the mask image.  */
   img->mask = w32_create_pixmap_from_bitmap_data (img->width, img->height,
-						  mask_img);
+                                                  mask_img);
   /* Fill in the background_transparent field while we have the mask handy. */
   SelectObject (ximg, img->mask);
   image_background_transparent (img, f, ximg);
@@ -5049,7 +5049,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
 
 
 /***********************************************************************
-		       PBM (mono, gray, color)
+                       PBM (mono, gray, color)
  ***********************************************************************/
 
 static bool pbm_image_p (Lisp_Object object);
@@ -5192,17 +5192,17 @@ pbm_load (struct frame *f, struct image *img)
     {
       file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
+          return 0;
+        }
 
       contents = slurp_file (SSDATA (file), &size);
       if (contents == NULL)
-	{
-	  image_error ("Error reading `%s'", file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Error reading `%s'", file, Qnil);
+          return 0;
+        }
 
       p = contents;
       end = contents + size;
@@ -5212,10 +5212,10 @@ pbm_load (struct frame *f, struct image *img)
       Lisp_Object data;
       data = image_spec_value (img->spec, QCdata, NULL);
       if (!STRINGP (data))
-	{
-	  image_error ("Invalid image data `%s'", data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       p = SDATA (data);
       end = p + SBYTES (data);
     }
@@ -5270,10 +5270,10 @@ pbm_load (struct frame *f, struct image *img)
     {
       max_color_idx = pbm_scan_number (&p, end);
       if (max_color_idx > 65535 || max_color_idx < 0)
-	{
-	  image_error ("Unsupported maximum PBM color value", Qnil, Qnil);
-	  goto error;
-	}
+        {
+          image_error ("Unsupported maximum PBM color value", Qnil, Qnil);
+          goto error;
+        }
     }
 
   if (!check_image_size (f, width, height))
@@ -5301,106 +5301,106 @@ pbm_load (struct frame *f, struct image *img)
 
       /* Get foreground and background colors, maybe allocate colors.  */
       if (fmt[PBM_FOREGROUND].count
-	  && STRINGP (fmt[PBM_FOREGROUND].value))
-	fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
+          && STRINGP (fmt[PBM_FOREGROUND].value))
+        fg = x_alloc_image_color (f, img, fmt[PBM_FOREGROUND].value, fg);
       if (fmt[PBM_BACKGROUND].count
-	  && STRINGP (fmt[PBM_BACKGROUND].value))
-	{
-	  bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
-	  img->background = bg;
-	  img->background_valid = 1;
-	}
+          && STRINGP (fmt[PBM_BACKGROUND].value))
+        {
+          bg = x_alloc_image_color (f, img, fmt[PBM_BACKGROUND].value, bg);
+          img->background = bg;
+          img->background_valid = 1;
+        }
 
       for (y = 0; y < height; ++y)
-	for (x = 0; x < width; ++x)
-	  {
-	    if (raw_p)
-	      {
-		if ((x & 7) == 0)
-		  {
-		    if (p >= end)
-		      {
-			x_destroy_x_image (ximg);
-			x_clear_image (f, img);
-			image_error ("Invalid image size in image `%s'",
-				     img->spec, Qnil);
-			goto error;
-		      }
-		    c = *p++;
-		  }
-		g = c & 0x80;
-		c <<= 1;
-	      }
-	    else
-	      g = pbm_scan_number (&p, end);
-
-	    XPutPixel (ximg, x, y, g ? fg : bg);
-	  }
+        for (x = 0; x < width; ++x)
+          {
+            if (raw_p)
+              {
+                if ((x & 7) == 0)
+                  {
+                    if (p >= end)
+                      {
+                        x_destroy_x_image (ximg);
+                        x_clear_image (f, img);
+                        image_error ("Invalid image size in image `%s'",
+                                     img->spec, Qnil);
+                        goto error;
+                      }
+                    c = *p++;
+                  }
+                g = c & 0x80;
+                c <<= 1;
+              }
+            else
+              g = pbm_scan_number (&p, end);
+
+            XPutPixel (ximg, x, y, g ? fg : bg);
+          }
     }
   else
     {
       int expected_size = height * width;
       if (max_color_idx > 255)
-	expected_size *= 2;
+        expected_size *= 2;
       if (type == PBM_COLOR)
-	expected_size *= 3;
+        expected_size *= 3;
 
       if (raw_p && p + expected_size > end)
-	{
-	  x_destroy_x_image (ximg);
-	  x_clear_image (f, img);
-	  image_error ("Invalid image size in image `%s'",
-		       img->spec, Qnil);
-	  goto error;
-	}
+        {
+          x_destroy_x_image (ximg);
+          x_clear_image (f, img);
+          image_error ("Invalid image size in image `%s'",
+                       img->spec, Qnil);
+          goto error;
+        }
 
       for (y = 0; y < height; ++y)
-	for (x = 0; x < width; ++x)
-	  {
-	    int r, g, b;
-
-	    if (type == PBM_GRAY && raw_p)
-	      {
-		r = g = b = *p++;
-		if (max_color_idx > 255)
-		  r = g = b = r * 256 + *p++;
-	      }
-	    else if (type == PBM_GRAY)
-	      r = g = b = pbm_scan_number (&p, end);
-	    else if (raw_p)
-	      {
-		r = *p++;
-		if (max_color_idx > 255)
-		  r = r * 256 + *p++;
-		g = *p++;
-		if (max_color_idx > 255)
-		  g = g * 256 + *p++;
-		b = *p++;
-		if (max_color_idx > 255)
-		  b = b * 256 + *p++;
-	      }
-	    else
-	      {
-		r = pbm_scan_number (&p, end);
-		g = pbm_scan_number (&p, end);
-		b = pbm_scan_number (&p, end);
-	      }
-
-	    if (r < 0 || g < 0 || b < 0)
-	      {
-		x_destroy_x_image (ximg);
-		image_error ("Invalid pixel value in image `%s'",
-			     img->spec, Qnil);
-		goto error;
-	      }
-
-	    /* RGB values are now in the range 0..max_color_idx.
-	       Scale this to the range 0..0xffff supported by X.  */
-	    r = (double) r * 65535 / max_color_idx;
-	    g = (double) g * 65535 / max_color_idx;
-	    b = (double) b * 65535 / max_color_idx;
-	    XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
-	  }
+        for (x = 0; x < width; ++x)
+          {
+            int r, g, b;
+
+            if (type == PBM_GRAY && raw_p)
+              {
+                r = g = b = *p++;
+                if (max_color_idx > 255)
+                  r = g = b = r * 256 + *p++;
+              }
+            else if (type == PBM_GRAY)
+              r = g = b = pbm_scan_number (&p, end);
+            else if (raw_p)
+              {
+                r = *p++;
+                if (max_color_idx > 255)
+                  r = r * 256 + *p++;
+                g = *p++;
+                if (max_color_idx > 255)
+                  g = g * 256 + *p++;
+                b = *p++;
+                if (max_color_idx > 255)
+                  b = b * 256 + *p++;
+              }
+            else
+              {
+                r = pbm_scan_number (&p, end);
+                g = pbm_scan_number (&p, end);
+                b = pbm_scan_number (&p, end);
+              }
+
+            if (r < 0 || g < 0 || b < 0)
+              {
+                x_destroy_x_image (ximg);
+                image_error ("Invalid pixel value in image `%s'",
+                             img->spec, Qnil);
+                goto error;
+              }
+
+            /* RGB values are now in the range 0..max_color_idx.
+               Scale this to the range 0..0xffff supported by X.  */
+            r = (double) r * 65535 / max_color_idx;
+            g = (double) g * 65535 / max_color_idx;
+            b = (double) b * 65535 / max_color_idx;
+            XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
+          }
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -5432,7 +5432,7 @@ pbm_load (struct frame *f, struct image *img)
 
 
 /***********************************************************************
-				 PNG
+                                 PNG
  ***********************************************************************/
 
 #if defined (HAVE_PNG) || defined (HAVE_NS)
@@ -5524,21 +5524,21 @@ png_image_p (Lisp_Object object)
 DEF_IMGLIB_FN (png_voidp, png_get_io_ptr, (png_structp));
 DEF_IMGLIB_FN (int, png_sig_cmp, (png_bytep, png_size_t, png_size_t));
 DEF_IMGLIB_FN (png_structp, png_create_read_struct, (png_const_charp, png_voidp,
-						     png_error_ptr, png_error_ptr));
+                                                     png_error_ptr, png_error_ptr));
 DEF_IMGLIB_FN (png_infop, png_create_info_struct, (png_structp));
 DEF_IMGLIB_FN (void, png_destroy_read_struct, (png_structpp, png_infopp, png_infopp));
 DEF_IMGLIB_FN (void, png_set_read_fn, (png_structp, png_voidp, png_rw_ptr));
 DEF_IMGLIB_FN (void, png_set_sig_bytes, (png_structp, int));
 DEF_IMGLIB_FN (void, png_read_info, (png_structp, png_infop));
 DEF_IMGLIB_FN (png_uint_32, png_get_IHDR, (png_structp, png_infop,
-			      png_uint_32 *, png_uint_32 *,
-			      int *, int *, int *, int *, int *));
+                              png_uint_32 *, png_uint_32 *,
+                              int *, int *, int *, int *, int *));
 DEF_IMGLIB_FN (png_uint_32, png_get_valid, (png_structp, png_infop, png_uint_32));
 DEF_IMGLIB_FN (void, png_set_strip_16, (png_structp));
 DEF_IMGLIB_FN (void, png_set_expand, (png_structp));
 DEF_IMGLIB_FN (void, png_set_gray_to_rgb, (png_structp));
 DEF_IMGLIB_FN (void, png_set_background, (png_structp, png_color_16p,
-				    int, int, double));
+                                    int, int, double));
 DEF_IMGLIB_FN (png_uint_32, png_get_bKGD, (png_structp, png_infop, png_color_16p *));
 DEF_IMGLIB_FN (void, png_read_update_info, (png_structp, png_infop));
 DEF_IMGLIB_FN (png_byte, png_get_channels, (png_structp, png_infop));
@@ -5747,35 +5747,35 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     {
       file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
+          return 0;
+        }
 
       /* Open the image file.  */
       fp = emacs_fopen (SSDATA (file), "rb");
       if (!fp)
-	{
-	  image_error ("Cannot open image file `%s'", file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open image file `%s'", file, Qnil);
+          return 0;
+        }
 
       /* Check PNG signature.  */
       if (fread (sig, 1, sizeof sig, fp) != sizeof sig
-	  || fn_png_sig_cmp (sig, 0, sizeof sig))
-	{
-	  fclose (fp);
-	  image_error ("Not a PNG file: `%s'", file, Qnil);
-	  return 0;
-	}
+          || fn_png_sig_cmp (sig, 0, sizeof sig))
+        {
+          fclose (fp);
+          image_error ("Not a PNG file: `%s'", file, Qnil);
+          return 0;
+        }
     }
   else
     {
       if (!STRINGP (specified_data))
-	{
-	  image_error ("Invalid image data `%s'", specified_data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
 
       /* Read from memory.  */
       tbr.bytes = SDATA (specified_data);
@@ -5784,11 +5784,11 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
       /* Check PNG signature.  */
       if (tbr.len < sizeof sig
-	  || fn_png_sig_cmp (tbr.bytes, 0, sizeof sig))
-	{
-	  image_error ("Not a PNG image: `%s'", img->spec, Qnil);
-	  return 0;
-	}
+          || fn_png_sig_cmp (tbr.bytes, 0, sizeof sig))
+        {
+          image_error ("Not a PNG image: `%s'", img->spec, Qnil);
+          return 0;
+        }
 
       /* Need to skip past the signature.  */
       tbr.bytes += sizeof (sig);
@@ -5796,8 +5796,8 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Initialize read and info structs for PNG lib.  */
   png_ptr = fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
-				       NULL, my_png_error,
-				       my_png_warning);
+                                       NULL, my_png_error,
+                                       my_png_warning);
   if (png_ptr)
     {
       info_ptr = fn_png_create_info_struct (png_ptr);
@@ -5828,11 +5828,11 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     {
     error:
       if (c->png_ptr)
-	fn_png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
+        fn_png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
       xfree (c->pixels);
       xfree (c->rows);
       if (c->fp)
-	fclose (c->fp);
+        fclose (c->fp);
       return 0;
     }
 
@@ -5848,10 +5848,10 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
   fn_png_set_sig_bytes (png_ptr, sizeof sig);
   fn_png_read_info (png_ptr, info_ptr);
   fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-		   &interlace_type, NULL, NULL);
+                   &interlace_type, NULL, NULL);
 
   if (! (width <= INT_MAX && height <= INT_MAX
-	 && check_image_size (f, width, height)))
+         && check_image_size (f, width, height)))
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       goto error;
@@ -5893,26 +5893,26 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     {
       /* png_color_16 *image_bg; */
       Lisp_Object specified_bg
-	= image_spec_value (img->spec, QCbackground, NULL);
+        = image_spec_value (img->spec, QCbackground, NULL);
       XColor color;
 
       /* If the user specified a color, try to use it; if not, use the
-	 current frame background, ignoring any default background
-	 color set by the image.  */
+         current frame background, ignoring any default background
+         color set by the image.  */
       if (STRINGP (specified_bg)
-	  ? x_defined_color (f, SSDATA (specified_bg), &color, false)
-	  : (x_query_frame_background_color (f, &color), true))
-	/* The user specified `:background', use that.  */
-	{
-	  int shift = bit_depth == 16 ? 0 : 8;
-	  png_color_16 bg = { 0 };
-	  bg.red = color.red >> shift;
-	  bg.green = color.green >> shift;
-	  bg.blue = color.blue >> shift;
-
-	  fn_png_set_background (png_ptr, &bg,
-				 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
-	}
+          ? x_defined_color (f, SSDATA (specified_bg), &color, false)
+          : (x_query_frame_background_color (f, &color), true))
+        /* The user specified `:background', use that.  */
+        {
+          int shift = bit_depth == 16 ? 0 : 8;
+          png_color_16 bg = { 0 };
+          bg.red = color.red >> shift;
+          bg.green = color.green >> shift;
+          bg.blue = color.blue >> shift;
+
+          fn_png_set_background (png_ptr, &bg,
+                                 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+        }
     }
 
   /* Update info structure.  */
@@ -5952,7 +5952,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
   if (channels == 4
       && !transparent_p
       && !image_create_x_image_and_pixmap (f, img, width, height, 1,
-					   &mask_img, 1))
+                                           &mask_img, 1))
     {
       x_destroy_x_image (ximg);
       x_clear_image_1 (f, img, CLEAR_IMAGE_PIXMAP);
@@ -5967,36 +5967,36 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
       png_byte *p = rows[y];
 
       for (x = 0; x < width; ++x)
-	{
-	  int r, g, b;
-
-	  r = *p++ << 8;
-	  g = *p++ << 8;
-	  b = *p++ << 8;
-	  XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
-	  /* An alpha channel, aka mask channel, associates variable
-	     transparency with an image.  Where other image formats
-	     support binary transparency---fully transparent or fully
-	     opaque---PNG allows up to 254 levels of partial transparency.
-	     The PNG library implements partial transparency by combining
-	     the image with a specified background color.
-
-	     I'm not sure how to handle this here nicely: because the
-	     background on which the image is displayed may change, for
-	     real alpha channel support, it would be necessary to create
-	     a new image for each possible background.
-
-	     What I'm doing now is that a mask is created if we have
-	     boolean transparency information.  Otherwise I'm using
-	     the frame's background color to combine the image with.  */
-
-	  if (channels == 4)
-	    {
-	      if (mask_img)
-		XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW : PIX_MASK_RETAIN);
-	      ++p;
-	    }
-	}
+        {
+          int r, g, b;
+
+          r = *p++ << 8;
+          g = *p++ << 8;
+          b = *p++ << 8;
+          XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
+          /* An alpha channel, aka mask channel, associates variable
+             transparency with an image.  Where other image formats
+             support binary transparency---fully transparent or fully
+             opaque---PNG allows up to 254 levels of partial transparency.
+             The PNG library implements partial transparency by combining
+             the image with a specified background color.
+
+             I'm not sure how to handle this here nicely: because the
+             background on which the image is displayed may change, for
+             real alpha channel support, it would be necessary to create
+             a new image for each possible background.
+
+             What I'm doing now is that a mask is created if we have
+             boolean transparency information.  Otherwise I'm using
+             the frame's background color to combine the image with.  */
+
+          if (channels == 4)
+            {
+              if (mask_img)
+                XPutPixel (mask_img, x, y, *p > 0 ? PIX_MASK_DRAW : PIX_MASK_RETAIN);
+              ++p;
+            }
+        }
     }
 
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
@@ -6005,10 +6005,10 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     {
       png_color_16 *bg;
       if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
-	{
-	  img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
-	  img->background_valid = 1;
-	}
+        {
+          img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
+          img->background_valid = 1;
+        }
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -6036,7 +6036,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
   if (mask_img)
     {
       /* Fill in the background_transparent field while we have the
-	 mask handy.  Casting avoids a GCC warning.  */
+         mask handy.  Casting avoids a GCC warning.  */
       image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
 
       image_put_x_image (f, img, mask_img, 1);
@@ -6067,7 +6067,7 @@ png_load (struct frame *f, struct image *img)
 
 
 /***********************************************************************
-				 JPEG
+                                 JPEG
  ***********************************************************************/
 
 #if defined (HAVE_JPEG) || defined (HAVE_NS)
@@ -6312,7 +6312,7 @@ our_memory_skip_input_data (j_decompress_ptr cinfo, long int num_bytes)
   if (src)
     {
       if (num_bytes > src->bytes_in_buffer)
-	ERREXIT (cinfo, JERR_INPUT_EOF);
+        ERREXIT (cinfo, JERR_INPUT_EOF);
 
       src->bytes_in_buffer -= num_bytes;
       src->next_input_byte += num_bytes;
@@ -6333,7 +6333,7 @@ jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, ptrdiff_t len)
     {
       /* First time for this JPEG object?  */
       src = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
-				     JPOOL_PERMANENT, sizeof *src);
+                                     JPOOL_PERMANENT, sizeof *src);
       cinfo->src = src;
       src->next_input_byte = data;
     }
@@ -6435,11 +6435,11 @@ jpeg_file_src (j_decompress_ptr cinfo, FILE *fp)
     {
       /* First time for this JPEG object?  */
       src = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
-				     JPOOL_PERMANENT, sizeof *src);
+                                     JPOOL_PERMANENT, sizeof *src);
       cinfo->src = (struct jpeg_source_mgr *) src;
       src->buffer = cinfo->mem->alloc_small ((j_common_ptr) cinfo,
-					     JPOOL_PERMANENT,
-					     JPEG_STDIO_BUFFER_SIZE);
+                                             JPOOL_PERMANENT,
+                                             JPEG_STDIO_BUFFER_SIZE);
     }
 
   src->file = fp;
@@ -6459,7 +6459,7 @@ jpeg_file_src (j_decompress_ptr cinfo, FILE *fp)
 
 static bool
 jpeg_load_body (struct frame *f, struct image *img,
-		struct my_jpeg_error_mgr *mgr)
+                struct my_jpeg_error_mgr *mgr)
 {
   Lisp_Object file, specified_file;
   Lisp_Object specified_data;
@@ -6479,17 +6479,17 @@ jpeg_load_body (struct frame *f, struct image *img,
     {
       file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
+          return 0;
+        }
 
       fp = emacs_fopen (SSDATA (file), "rb");
       if (fp == NULL)
-	{
-	  image_error ("Cannot open `%s'", file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open `%s'", file, Qnil);
+          return 0;
+        }
     }
   else if (!STRINGP (specified_data))
     {
@@ -6504,27 +6504,27 @@ jpeg_load_body (struct frame *f, struct image *img,
   if (sys_setjmp (mgr->setjmp_buffer))
     {
       switch (mgr->failure_code)
-	{
-	case MY_JPEG_ERROR_EXIT:
-	  {
-	    char buf[JMSG_LENGTH_MAX];
-	    mgr->cinfo.err->format_message ((j_common_ptr) &mgr->cinfo, buf);
-	    image_error ("Error reading JPEG image `%s': %s", img->spec,
-			 build_string (buf));
-	    break;
-	  }
-
-	case MY_JPEG_INVALID_IMAGE_SIZE:
-	  image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
-	  break;
-
-	case MY_JPEG_CANNOT_CREATE_X:
-	  break;
-	}
+        {
+        case MY_JPEG_ERROR_EXIT:
+          {
+            char buf[JMSG_LENGTH_MAX];
+            mgr->cinfo.err->format_message ((j_common_ptr) &mgr->cinfo, buf);
+            image_error ("Error reading JPEG image `%s': %s", img->spec,
+                         build_string (buf));
+            break;
+          }
+
+        case MY_JPEG_INVALID_IMAGE_SIZE:
+          image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
+          break;
+
+        case MY_JPEG_CANNOT_CREATE_X:
+          break;
+        }
 
       /* Close the input file and destroy the JPEG object.  */
       if (fp)
-	fclose (fp);
+        fclose (fp);
       fn_jpeg_destroy_decompress (&mgr->cinfo);
 
       /* If we already have an XImage, free that.  */
@@ -6536,19 +6536,19 @@ jpeg_load_body (struct frame *f, struct image *img,
     }
 
   /* Create the JPEG decompression object.  Let it read from fp.
-	 Read the JPEG image header.  */
+         Read the JPEG image header.  */
   fn_jpeg_CreateDecompress (&mgr->cinfo, JPEG_LIB_VERSION, sizeof *&mgr->cinfo);
 
   if (NILP (specified_data))
     jpeg_file_src (&mgr->cinfo, fp);
   else
     jpeg_memory_src (&mgr->cinfo, SDATA (specified_data),
-		     SBYTES (specified_data));
+                     SBYTES (specified_data));
 
   fn_jpeg_read_header (&mgr->cinfo, 1);
 
   /* Customize decompression so that color quantization will be used.
-	 Start decompression.  */
+         Start decompression.  */
   mgr->cinfo.quantize_colors = 1;
   fn_jpeg_start_decompress (&mgr->cinfo);
   width = img->width = mgr->cinfo.output_width;
@@ -6591,12 +6591,12 @@ jpeg_load_body (struct frame *f, struct image *img,
 
     for (i = 0; i < mgr->cinfo.actual_number_of_colors; ++i)
       {
-	/* Multiply RGB values with 255 because X expects RGB values
-	   in the range 0..0xffff.  */
-	int r = mgr->cinfo.colormap[ir][i] << 8;
-	int g = mgr->cinfo.colormap[ig][i] << 8;
-	int b = mgr->cinfo.colormap[ib][i] << 8;
-	colors[i] = lookup_rgb_color (f, r, g, b);
+        /* Multiply RGB values with 255 because X expects RGB values
+           in the range 0..0xffff.  */
+        int r = mgr->cinfo.colormap[ir][i] << 8;
+        int g = mgr->cinfo.colormap[ig][i] << 8;
+        int b = mgr->cinfo.colormap[ib][i] << 8;
+        colors[i] = lookup_rgb_color (f, r, g, b);
       }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -6609,12 +6609,12 @@ jpeg_load_body (struct frame *f, struct image *img,
   /* Read pixels.  */
   row_stride = width * mgr->cinfo.output_components;
   buffer = mgr->cinfo.mem->alloc_sarray ((j_common_ptr) &mgr->cinfo,
-					 JPOOL_IMAGE, row_stride, 1);
+                                         JPOOL_IMAGE, row_stride, 1);
   for (y = 0; y < height; ++y)
     {
       fn_jpeg_read_scanlines (&mgr->cinfo, buffer, 1);
       for (x = 0; x < mgr->cinfo.output_width; ++x)
-	XPutPixel (ximg, x, y, colors[buffer[0][x]]);
+        XPutPixel (ximg, x, y, colors[buffer[0][x]]);
     }
 
   /* Clean up.  */
@@ -6647,8 +6647,8 @@ static bool
 jpeg_load (struct frame *f, struct image *img)
 {
   return ns_load_image (f, img,
-			image_spec_value (img->spec, QCfile, NULL),
-			image_spec_value (img->spec, QCdata, NULL));
+                        image_spec_value (img->spec, QCfile, NULL),
+                        image_spec_value (img->spec, QCdata, NULL));
 }
 #endif  /* HAVE_NS */
 
@@ -6657,7 +6657,7 @@ jpeg_load (struct frame *f, struct image *img)
 
 
 /***********************************************************************
-				 TIFF
+                                 TIFF
  ***********************************************************************/
 
 #if defined (HAVE_TIFF) || defined (HAVE_NS)
@@ -6751,9 +6751,9 @@ DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler));
 DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetWarningHandler, (TIFFErrorHandler));
 DEF_IMGLIB_FN (TIFF *, TIFFOpen, (const char *, const char *));
 DEF_IMGLIB_FN (TIFF *, TIFFClientOpen, (const char *, const char *, thandle_t,
-				TIFFReadWriteProc, TIFFReadWriteProc,
-				TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
-				TIFFMapFileProc, TIFFUnmapFileProc));
+                                TIFFReadWriteProc, TIFFReadWriteProc,
+                                TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
+                                TIFFMapFileProc, TIFFUnmapFileProc));
 DEF_IMGLIB_FN (int, TIFFGetField, (TIFF *, ttag_t, ...));
 DEF_IMGLIB_FN (int, TIFFReadRGBAImage, (TIFF *, uint32, uint32, uint32 *, int));
 DEF_IMGLIB_FN (void, TIFFClose, (TIFF *));
@@ -6897,7 +6897,7 @@ tiff_handler (const char *, const char *, const char *, va_list)
   ATTRIBUTE_FORMAT_PRINTF (3, 0);
 MINGW_STATIC void
 tiff_handler (const char *log_format, const char *title,
-	      const char *format, va_list ap)
+              const char *format, va_list ap)
 {
   /* doprnt is not suitable here, as TIFF handlers are called from
      libtiff and are passed arbitrary printf directives.  Instead, use
@@ -6907,7 +6907,7 @@ tiff_handler (const char *log_format, const char *title,
   char buf[4000];
   int len = vsnprintf (buf, sizeof buf, format, ap);
   add_to_log (log_format, build_string (title),
-	      make_string (buf, max (0, min (len, sizeof buf - 1))));
+              make_string (buf, max (0, min (len, sizeof buf - 1))));
 }
 #undef MINGW_STATIC
 
@@ -6956,10 +6956,10 @@ tiff_load (struct frame *f, struct image *img)
       /* Read from a file */
       file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
+          return 0;
+        }
 #ifdef WINDOWSNT
       file = ansi_encode_filename (file);
 #endif
@@ -6967,18 +6967,18 @@ tiff_load (struct frame *f, struct image *img)
       /* Try to open the image file.  */
       tiff = fn_TIFFOpen (SSDATA (file), "r");
       if (tiff == NULL)
-	{
-	  image_error ("Cannot open `%s'", file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open `%s'", file, Qnil);
+          return 0;
+        }
     }
   else
     {
       if (!STRINGP (specified_data))
-	{
-	  image_error ("Invalid image data `%s'", specified_data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
 
       /* Memory source! */
       memsrc.bytes = SDATA (specified_data);
@@ -6986,19 +6986,19 @@ tiff_load (struct frame *f, struct image *img)
       memsrc.index = 0;
 
       tiff = fn_TIFFClientOpen ("memory_source", "r", (thandle_t)&memsrc,
-				tiff_read_from_memory,
-				tiff_write_from_memory,
-				tiff_seek_in_memory,
-				tiff_close_memory,
-				tiff_size_of_memory,
-				tiff_mmap_memory,
-				tiff_unmap_memory);
+                                tiff_read_from_memory,
+                                tiff_write_from_memory,
+                                tiff_seek_in_memory,
+                                tiff_close_memory,
+                                tiff_size_of_memory,
+                                tiff_mmap_memory,
+                                tiff_unmap_memory);
 
       if (!tiff)
-	{
-	  image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open memory source for `%s'", img->spec, Qnil);
+          return 0;
+        }
     }
 
   image = image_spec_value (img->spec, QCindex, NULL);
@@ -7006,13 +7006,13 @@ tiff_load (struct frame *f, struct image *img)
     {
       EMACS_INT ino = XFASTINT (image);
       if (! (TYPE_MINIMUM (tdir_t) <= ino && ino <= TYPE_MAXIMUM (tdir_t)
-	     && fn_TIFFSetDirectory (tiff, ino)))
-	{
-	  image_error ("Invalid image number `%s' in image `%s'",
-		       image, img->spec);
-	  fn_TIFFClose (tiff);
-	  return 0;
-	}
+             && fn_TIFFSetDirectory (tiff, ino)))
+        {
+          image_error ("Invalid image number `%s' in image `%s'",
+                       image, img->spec);
+          fn_TIFFClose (tiff);
+          return 0;
+        }
     }
 
   /* Get width and height of the image, and allocate a raster buffer
@@ -7029,8 +7029,8 @@ tiff_load (struct frame *f, struct image *img)
 
   /* Create the X image and pixmap.  */
   if (! (height <= min (PTRDIFF_MAX, SIZE_MAX) / sizeof *buf / width
-	 && image_create_x_image_and_pixmap (f, img, width, height, 0,
-					     &ximg, 0)))
+         && image_create_x_image_and_pixmap (f, img, width, height, 0,
+                                             &ximg, 0)))
     {
       fn_TIFFClose (tiff);
       return 0;
@@ -7046,8 +7046,8 @@ tiff_load (struct frame *f, struct image *img)
 
   if (count > 1)
     img->lisp_data = Fcons (Qcount,
-			    Fcons (make_number (count),
-				   img->lisp_data));
+                            Fcons (make_number (count),
+                                   img->lisp_data));
 
   fn_TIFFClose (tiff);
   if (!rc)
@@ -7066,13 +7066,13 @@ tiff_load (struct frame *f, struct image *img)
       uint32 *row = buf + y * width;
 
       for (x = 0; x < width; ++x)
-	{
-	  uint32 abgr = row[x];
-	  int r = TIFFGetR (abgr) << 8;
-	  int g = TIFFGetG (abgr) << 8;
-	  int b = TIFFGetB (abgr) << 8;
-	  XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
-	}
+        {
+          uint32 abgr = row[x];
+          int r = TIFFGetR (abgr) << 8;
+          int g = TIFFGetG (abgr) << 8;
+          int b = TIFFGetB (abgr) << 8;
+          XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
+        }
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -7113,7 +7113,7 @@ tiff_load (struct frame *f, struct image *img)
 
 
 /***********************************************************************
-				 GIF
+                                 GIF
  ***********************************************************************/
 
 #if defined (HAVE_GIF) || defined (HAVE_NS)
@@ -7344,10 +7344,10 @@ gif_load (struct frame *f, struct image *img)
     {
       file = x_find_image_file (specified_file);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", specified_file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", specified_file, Qnil);
+          return 0;
+        }
 #ifdef WINDOWSNT
       file = ansi_encode_filename (file);
 #endif
@@ -7356,27 +7356,27 @@ gif_load (struct frame *f, struct image *img)
 #if GIFLIB_MAJOR < 5
       gif = fn_DGifOpenFileName (SSDATA (file));
       if (gif == NULL)
-	{
-	  image_error ("Cannot open `%s'", file, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open `%s'", file, Qnil);
+          return 0;
+        }
 #else
       gif = fn_DGifOpenFileName (SSDATA (file), &gif_err);
       if (gif == NULL)
-	{
-	  image_error ("Cannot open `%s': %s",
-		       file, build_string (fn_GifErrorString (gif_err)));
-	  return 0;
-	}
+        {
+          image_error ("Cannot open `%s': %s",
+                       file, build_string (fn_GifErrorString (gif_err)));
+          return 0;
+        }
 #endif
     }
   else
     {
       if (!STRINGP (specified_data))
-	{
-	  image_error ("Invalid image data `%s'", specified_data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", specified_data, Qnil);
+          return 0;
+        }
 
       /* Read from memory! */
       current_gif_memory_src = &memsrc;
@@ -7387,18 +7387,18 @@ gif_load (struct frame *f, struct image *img)
 #if GIFLIB_MAJOR < 5
       gif = fn_DGifOpen (&memsrc, gif_read_from_memory);
       if (!gif)
-	{
-	  image_error ("Cannot open memory source `%s'", img->spec, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot open memory source `%s'", img->spec, Qnil);
+          return 0;
+        }
 #else
       gif = fn_DGifOpen (&memsrc, gif_read_from_memory, &gif_err);
       if (!gif)
-	{
-	  image_error ("Cannot open memory source `%s': %s",
-		       img->spec, build_string (fn_GifErrorString (gif_err)));
-	  return 0;
-	}
+        {
+          image_error ("Cannot open memory source `%s': %s",
+                       img->spec, build_string (fn_GifErrorString (gif_err)));
+          return 0;
+        }
 #endif
     }
 
@@ -7425,10 +7425,10 @@ gif_load (struct frame *f, struct image *img)
     idx = INTEGERP (image_number) ? XFASTINT (image_number) : 0;
     if (idx < 0 || idx >= gif->ImageCount)
       {
-	image_error ("Invalid image number `%s' in image `%s'",
-		     image_number, img->spec);
-	fn_DGifCloseFile (gif);
-	return 0;
+        image_error ("Invalid image number `%s' in image `%s'",
+                     image_number, img->spec);
+        fn_DGifCloseFile (gif);
+        return 0;
       }
   }
 
@@ -7459,13 +7459,13 @@ gif_load (struct frame *f, struct image *img)
       int subimg_top = subimage->ImageDesc.Top;
       int subimg_left = subimage->ImageDesc.Left;
       if (! (0 <= subimg_width && 0 <= subimg_height
-	     && 0 <= subimg_top && subimg_top <= height - subimg_height
-	     && 0 <= subimg_left && subimg_left <= width - subimg_width))
-	{
-	  image_error ("Subimage does not fit in image", Qnil, Qnil);
-	  fn_DGifCloseFile (gif);
-	  return 0;
-	}
+             && 0 <= subimg_top && subimg_top <= height - subimg_height
+             && 0 <= subimg_left && subimg_left <= width - subimg_width))
+        {
+          image_error ("Subimage does not fit in image", Qnil, Qnil);
+          fn_DGifCloseFile (gif);
+          return 0;
+        }
     }
 
   /* Create the X image and pixmap.  */
@@ -7490,9 +7490,9 @@ gif_load (struct frame *f, struct image *img)
   for (y = img->corners[TOP_CORNER]; y < img->corners[BOT_CORNER]; ++y)
     {
       for (x = 0; x < img->corners[LEFT_CORNER]; ++x)
-	XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
+        XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
       for (x = img->corners[RIGHT_CORNER]; x < width; ++x)
-	XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
+        XPutPixel (ximg, x, y, FRAME_BACKGROUND_PIXEL (f));
     }
 
   /* Read the GIF image into the X image.   */
@@ -7505,11 +7505,11 @@ gif_load (struct frame *f, struct image *img)
   init_color_table ();
   if (STRINGP (specified_bg))
     bgcolor = x_alloc_image_color (f, img, specified_bg,
-				   FRAME_BACKGROUND_PIXEL (f));
+                                   FRAME_BACKGROUND_PIXEL (f));
   for (j = 0; j <= idx; ++j)
     {
       /* We use a local variable `raster' here because RasterBits is a
-	 char *, which invites problems with bytes >= 0x80.  */
+         char *, which invites problems with bytes >= 0x80.  */
       struct SavedImage *subimage = gif->SavedImages + j;
       unsigned char *raster = (unsigned char *) subimage->RasterBits;
       int transparency_color_index = -1;
@@ -7520,87 +7520,87 @@ gif_load (struct frame *f, struct image *img)
       int subimg_left = subimage->ImageDesc.Left;
 
       /* Find the Graphic Control Extension block for this sub-image.
-	 Extract the disposal method and transparency color.  */
+         Extract the disposal method and transparency color.  */
       for (i = 0; i < subimage->ExtensionBlockCount; i++)
-	{
-	  ExtensionBlock *extblock = subimage->ExtensionBlocks + i;
-
-	  if ((extblock->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION)
-	      && extblock->ByteCount == 4
-	      && extblock->Bytes[0] & 1)
-	    {
-	      /* From gif89a spec: 1 = "keep in place", 2 = "restore
-		 to background".  Treat any other value like 2.  */
-	      disposal = (extblock->Bytes[0] >> 2) & 7;
-	      transparency_color_index = (unsigned char) extblock->Bytes[3];
-	      break;
-	    }
-	}
+        {
+          ExtensionBlock *extblock = subimage->ExtensionBlocks + i;
+
+          if ((extblock->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION)
+              && extblock->ByteCount == 4
+              && extblock->Bytes[0] & 1)
+            {
+              /* From gif89a spec: 1 = "keep in place", 2 = "restore
+                 to background".  Treat any other value like 2.  */
+              disposal = (extblock->Bytes[0] >> 2) & 7;
+              transparency_color_index = (unsigned char) extblock->Bytes[3];
+              break;
+            }
+        }
 
       /* We can't "keep in place" the first subimage.  */
       if (j == 0)
-	disposal = 2;
+        disposal = 2;
 
       /* For disposal == 0, the spec says "No disposal specified. The
-	 decoder is not required to take any action."  In practice, it
-	 seems we need to treat this like "keep in place", see e.g.
-	 http://upload.wikimedia.org/wikipedia/commons/3/37/Clock.gif */
+         decoder is not required to take any action."  In practice, it
+         seems we need to treat this like "keep in place", see e.g.
+         http://upload.wikimedia.org/wikipedia/commons/3/37/Clock.gif */
       if (disposal == 0)
-	disposal = 1;
+        disposal = 1;
 
       /* Allocate subimage colors.  */
       memset (pixel_colors, 0, sizeof pixel_colors);
       gif_color_map = subimage->ImageDesc.ColorMap;
       if (!gif_color_map)
-	gif_color_map = gif->SColorMap;
+        gif_color_map = gif->SColorMap;
 
       if (gif_color_map)
-	for (i = 0; i < gif_color_map->ColorCount; ++i)
-	  {
-	    if (transparency_color_index == i)
-	      pixel_colors[i] = STRINGP (specified_bg)
-		? bgcolor : FRAME_BACKGROUND_PIXEL (f);
-	    else
-	      {
-		int r = gif_color_map->Colors[i].Red << 8;
-		int g = gif_color_map->Colors[i].Green << 8;
-		int b = gif_color_map->Colors[i].Blue << 8;
-		pixel_colors[i] = lookup_rgb_color (f, r, g, b);
-	      }
-	  }
+        for (i = 0; i < gif_color_map->ColorCount; ++i)
+          {
+            if (transparency_color_index == i)
+              pixel_colors[i] = STRINGP (specified_bg)
+                ? bgcolor : FRAME_BACKGROUND_PIXEL (f);
+            else
+              {
+                int r = gif_color_map->Colors[i].Red << 8;
+                int g = gif_color_map->Colors[i].Green << 8;
+                int b = gif_color_map->Colors[i].Blue << 8;
+                pixel_colors[i] = lookup_rgb_color (f, r, g, b);
+              }
+          }
 
       /* Apply the pixel values.  */
       if (GIFLIB_MAJOR < 5 && gif->SavedImages[j].ImageDesc.Interlace)
-	{
-	  int row, pass;
-
-	  for (y = 0, row = interlace_start[0], pass = 0;
-	       y < subimg_height;
-	       y++, row += interlace_increment[pass])
-	    {
-	      while (subimg_height <= row)
-		row = interlace_start[++pass];
-
-	      for (x = 0; x < subimg_width; x++)
-		{
-		  int c = raster[y * subimg_width + x];
-		  if (transparency_color_index != c || disposal != 1)
-		    XPutPixel (ximg, x + subimg_left, row + subimg_top,
-			       pixel_colors[c]);
-		}
-	    }
-	}
+        {
+          int row, pass;
+
+          for (y = 0, row = interlace_start[0], pass = 0;
+               y < subimg_height;
+               y++, row += interlace_increment[pass])
+            {
+              while (subimg_height <= row)
+                row = interlace_start[++pass];
+
+              for (x = 0; x < subimg_width; x++)
+                {
+                  int c = raster[y * subimg_width + x];
+                  if (transparency_color_index != c || disposal != 1)
+                    XPutPixel (ximg, x + subimg_left, row + subimg_top,
+                               pixel_colors[c]);
+                }
+            }
+        }
       else
-	{
-	  for (y = 0; y < subimg_height; ++y)
-	    for (x = 0; x < subimg_width; ++x)
-	      {
-		int c = raster[y * subimg_width + x];
-		if (transparency_color_index != c || disposal != 1)
-		  XPutPixel (ximg, x + subimg_left, y + subimg_top,
-			     pixel_colors[c]);
-	      }
-	}
+        {
+          for (y = 0; y < subimg_height; ++y)
+            for (x = 0; x < subimg_width; ++x)
+              {
+                int c = raster[y * subimg_width + x];
+                if (transparency_color_index != c || disposal != 1)
+                  XPutPixel (ximg, x + subimg_left, y + subimg_top,
+                             pixel_colors[c]);
+              }
+        }
     }
 
 #ifdef COLOR_TABLE_SUPPORT
@@ -7616,31 +7616,31 @@ gif_load (struct frame *f, struct image *img)
       int delay = 0;
       ExtensionBlock *ext = gif->SavedImages[idx].ExtensionBlocks;
       for (i = 0; i < gif->SavedImages[idx].ExtensionBlockCount; i++, ext++)
-	/* Append (... FUNCTION "BYTES") */
-	{
-	  img->lisp_data
-	    = Fcons (make_number (ext->Function),
-		     Fcons (make_unibyte_string (ext->Bytes, ext->ByteCount),
-			    img->lisp_data));
-	  if (ext->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION
-	      && ext->ByteCount == 4)
-	    {
-	      delay = ext->Bytes[2] << CHAR_BIT;
-	      delay |= ext->Bytes[1];
-	    }
-	}
+        /* Append (... FUNCTION "BYTES") */
+        {
+          img->lisp_data
+            = Fcons (make_number (ext->Function),
+                     Fcons (make_unibyte_string (ext->Bytes, ext->ByteCount),
+                            img->lisp_data));
+          if (ext->Function == GIF_LOCAL_DESCRIPTOR_EXTENSION
+              && ext->ByteCount == 4)
+            {
+              delay = ext->Bytes[2] << CHAR_BIT;
+              delay |= ext->Bytes[1];
+            }
+        }
       img->lisp_data = list2 (Qextension_data, img->lisp_data);
       if (delay)
-	img->lisp_data
-	  = Fcons (Qdelay,
-		   Fcons (make_float (delay / 100.0),
-			  img->lisp_data));
+        img->lisp_data
+          = Fcons (Qdelay,
+                   Fcons (make_float (delay / 100.0),
+                          img->lisp_data));
     }
 
   if (gif->ImageCount > 1)
     img->lisp_data = Fcons (Qcount,
-			    Fcons (make_number (gif->ImageCount),
-				   img->lisp_data));
+                            Fcons (make_number (gif->ImageCount),
+                                   img->lisp_data));
 
   fn_DGifCloseFile (gif);
 
@@ -7663,7 +7663,7 @@ gif_load (struct frame *f, struct image *img)
 {
   return ns_load_image (f, img,
                         image_spec_value (img->spec, QCfile, NULL),
-			image_spec_value (img->spec, QCdata, NULL));
+                        image_spec_value (img->spec, QCdata, NULL));
 }
 #endif /* HAVE_NS */
 
@@ -7673,7 +7673,7 @@ gif_load (struct frame *f, struct image *img)
 #ifdef HAVE_IMAGEMAGICK
 
 /***********************************************************************
-				 ImageMagick
+                                 ImageMagick
 ***********************************************************************/
 
 /* Scale an image size by returning SIZE / DIVISOR * MULTIPLIER,
@@ -7687,7 +7687,7 @@ scale_image_size (int size, size_t divisor, size_t multiplier)
       double s = size;
       double scaled = s * multiplier / divisor + 0.5;
       if (scaled < INT_MAX)
-	return scaled;
+        return scaled;
     }
   return INT_MAX;
 }
@@ -7697,8 +7697,8 @@ scale_image_size (int size, size_t divisor, size_t multiplier)
    *D_WIDTH x *D_HEIGHT.  Store -1 x -1 if the native size is OK.  */
 static void
 compute_image_size (size_t width, size_t height,
-		    Lisp_Object spec,
-		    int *d_width, int *d_height)
+                    Lisp_Object spec,
+                    int *d_width, int *d_height)
 {
   Lisp_Object value;
   int desired_width, desired_height;
@@ -7716,41 +7716,41 @@ compute_image_size (size_t width, size_t height,
     {
       value = image_spec_value (spec, QCmax_width, NULL);
       if (NATNUMP (value))
-	{
-	  int max_width = min (XFASTINT (value), INT_MAX);
-	  if (max_width < width)
-	    {
-	      /* The image is wider than :max-width. */
-	      desired_width = max_width;
-	      if (desired_height == -1)
-		{
-		  desired_height = scale_image_size (desired_width,
-						     width, height);
-		  value = image_spec_value (spec, QCmax_height, NULL);
-		  if (NATNUMP (value))
-		    {
-		      int max_height = min (XFASTINT (value), INT_MAX);
-		      if (max_height < desired_height)
-			{
-			  desired_height = max_height;
-			  desired_width = scale_image_size (desired_height,
-							    height, width);
-			}
-		    }
-		}
-	    }
-	}
+        {
+          int max_width = min (XFASTINT (value), INT_MAX);
+          if (max_width < width)
+            {
+              /* The image is wider than :max-width. */
+              desired_width = max_width;
+              if (desired_height == -1)
+                {
+                  desired_height = scale_image_size (desired_width,
+                                                     width, height);
+                  value = image_spec_value (spec, QCmax_height, NULL);
+                  if (NATNUMP (value))
+                    {
+                      int max_height = min (XFASTINT (value), INT_MAX);
+                      if (max_height < desired_height)
+                        {
+                          desired_height = max_height;
+                          desired_width = scale_image_size (desired_height,
+                                                            height, width);
+                        }
+                    }
+                }
+            }
+        }
     }
 
   if (desired_height == -1)
     {
       value = image_spec_value (spec, QCmax_height, NULL);
       if (NATNUMP (value))
-	{
-	  int max_height = min (XFASTINT (value), INT_MAX);
-	  if (max_height < height)
-	    desired_height = max_height;
-	}
+        {
+          int max_height = min (XFASTINT (value), INT_MAX);
+          if (max_height < height)
+            desired_height = max_height;
+        }
     }
 
   if (desired_width != -1 && desired_height == -1)
@@ -7815,7 +7815,7 @@ static struct image_keyword imagemagick_format[IMAGEMAGICK_LAST] =
     {":max-height",	IMAGE_INTEGER_VALUE,			0},
     {":max-width",	IMAGE_INTEGER_VALUE,			0},
     {":format",		IMAGE_SYMBOL_VALUE,			0},
-    {":rotation",	IMAGE_NUMBER_VALUE,     		0},
+    {":rotation",	IMAGE_NUMBER_VALUE,                     0},
     {":crop",		IMAGE_DONT_CHECK_VALUE_TYPE,		0}
   };
 
@@ -7874,7 +7874,7 @@ imagemagick_image_p (Lisp_Object object)
 #include <magick/version.h>
 #if 0x653 <= MagickLibVersion && MagickLibVersion <= 0x665
 extern WandExport void PixelGetMagickColor (const PixelWand *,
-					    MagickPixelPacket *);
+                                            MagickPixelPacket *);
 #endif
 
 /* Log ImageMagick error message.
@@ -7888,8 +7888,8 @@ imagemagick_error (MagickWand *wand)
 
   description = MagickGetException (wand, &severity);
   image_error ("ImageMagick error: %s",
-	       build_string (description),
-	       Qnil);
+               build_string (description),
+               Qnil);
   MagickRelinquishMemory (description);
 }
 
@@ -7945,7 +7945,7 @@ imagemagick_create_cache (char *signature)
 {
   struct animation_cache *cache
     = xmalloc (offsetof (struct animation_cache, signature)
-	       + strlen (signature) + 1);
+               + strlen (signature) + 1);
   cache->wand = 0;
   cache->index = 0;
   cache->next = 0;
@@ -7959,20 +7959,20 @@ imagemagick_prune_animation_cache (void)
 {
   struct animation_cache **pcache = &animation_cache;
   struct timespec old = timespec_sub (current_timespec (),
-				      make_timespec (60, 0));
+                                      make_timespec (60, 0));
 
   while (*pcache)
     {
       struct animation_cache *cache = *pcache;
       if (timespec_cmp (old, cache->update_time) <= 0)
-	pcache = &cache->next;
+        pcache = &cache->next;
       else
-	{
-	  if (cache->wand)
-	    DestroyMagickWand (cache->wand);
-	  *pcache = cache->next;
-	  xfree (cache);
-	}
+        {
+          if (cache->wand)
+            DestroyMagickWand (cache->wand);
+          *pcache = cache->next;
+          xfree (cache);
+        }
     }
 }
 
@@ -7989,12 +7989,12 @@ imagemagick_get_animation_cache (MagickWand *wand)
     {
       cache = *pcache;
       if (! cache)
-	{
+        {
           *pcache = cache = imagemagick_create_cache (signature);
           break;
         }
       if (strcmp (signature, cache->signature) == 0)
-	break;
+        break;
       pcache = &cache->next;
     }
 
@@ -8017,7 +8017,7 @@ imagemagick_compute_animated_image (MagickWand *super_wand, int ino)
     {
       composite_wand = MagickGetImage (super_wand);
       if (cache->wand)
-	DestroyMagickWand (cache->wand);
+        DestroyMagickWand (cache->wand);
     }
   else
     composite_wand = cache->wand;
@@ -8040,71 +8040,71 @@ imagemagick_compute_animated_image (MagickWand *super_wand, int ino)
       sub_wand = MagickGetImage (super_wand);
 
       MagickGetImagePage (sub_wand, &source_width, &source_height,
-			  &source_left, &source_top);
+                          &source_left, &source_top);
 
       /* This flag says how to handle transparent pixels.  */
       dispose = MagickGetImageDispose (sub_wand);
 
       source_iterator = NewPixelIterator (sub_wand);
       if (! source_iterator)
-	{
-	  DestroyMagickWand (composite_wand);
-	  DestroyMagickWand (sub_wand);
-	  cache->wand = NULL;
-	  image_error ("Imagemagick pixel iterator creation failed",
-		       Qnil, Qnil);
-	  return NULL;
-	}
+        {
+          DestroyMagickWand (composite_wand);
+          DestroyMagickWand (sub_wand);
+          cache->wand = NULL;
+          image_error ("Imagemagick pixel iterator creation failed",
+                       Qnil, Qnil);
+          return NULL;
+        }
 
       dest_iterator = NewPixelIterator (composite_wand);
       if (! dest_iterator)
-	{
-	  DestroyMagickWand (composite_wand);
-	  DestroyMagickWand (sub_wand);
-	  DestroyPixelIterator (source_iterator);
-	  cache->wand = NULL;
-	  image_error ("Imagemagick pixel iterator creation failed",
-		       Qnil, Qnil);
-	  return NULL;
-	}
+        {
+          DestroyMagickWand (composite_wand);
+          DestroyMagickWand (sub_wand);
+          DestroyPixelIterator (source_iterator);
+          cache->wand = NULL;
+          image_error ("Imagemagick pixel iterator creation failed",
+                       Qnil, Qnil);
+          return NULL;
+        }
 
       /* The sub-image may not start at origin, so move the destination
-	 iterator to where the sub-image should start. */
+         iterator to where the sub-image should start. */
       if (source_top > 0)
-	{
-	  PixelSetIteratorRow (dest_iterator, source_top);
-	  lines = source_top;
-	}
+        {
+          PixelSetIteratorRow (dest_iterator, source_top);
+          lines = source_top;
+        }
 
       while ((source = PixelGetNextIteratorRow (source_iterator, &source_width))
-	     != NULL)
-	{
-	  ptrdiff_t x;
-
-	  /* Sanity check.  This shouldn't happen, but apparently
-	     does in some pictures.  */
-	  if (++lines >= dest_height)
-	    break;
-
-	  dest = PixelGetNextIteratorRow (dest_iterator, &dest_width);
-	  for (x = 0; x < source_width; x++)
-	    {
-	      /* Sanity check.  This shouldn't happen, but apparently
-		 also does in some pictures.  */
-	      if (x + source_left > dest_width - 1)
-		break;
-	      /* Normally we only copy over non-transparent pixels,
-		 but if the disposal method is "Background", then we
-		 copy over all pixels.  */
-	      if (dispose == BackgroundDispose ||
-		  PixelGetAlpha (source[x]))
-		{
-		  PixelGetMagickColor (source[x], &pixel);
-		  PixelSetMagickColor (dest[x + source_left], &pixel);
-		}
-	    }
-	  PixelSyncIterator (dest_iterator);
-	}
+             != NULL)
+        {
+          ptrdiff_t x;
+
+          /* Sanity check.  This shouldn't happen, but apparently
+             does in some pictures.  */
+          if (++lines >= dest_height)
+            break;
+
+          dest = PixelGetNextIteratorRow (dest_iterator, &dest_width);
+          for (x = 0; x < source_width; x++)
+            {
+              /* Sanity check.  This shouldn't happen, but apparently
+                 also does in some pictures.  */
+              if (x + source_left > dest_width - 1)
+                break;
+              /* Normally we only copy over non-transparent pixels,
+                 but if the disposal method is "Background", then we
+                 copy over all pixels.  */
+              if (dispose == BackgroundDispose ||
+                  PixelGetAlpha (source[x]))
+                {
+                  PixelGetMagickColor (source[x], &pixel);
+                  PixelSetMagickColor (dest[x + source_left], &pixel);
+                }
+            }
+          PixelSyncIterator (dest_iterator);
+        }
 
       DestroyPixelIterator (source_iterator);
       DestroyPixelIterator (dest_iterator);
@@ -8134,8 +8134,8 @@ imagemagick_compute_animated_image (MagickWand *super_wand, int ino)
 
 static bool
 imagemagick_load_image (struct frame *f, struct image *img,
-			unsigned char *contents, unsigned int size,
-			char *filename)
+                        unsigned char *contents, unsigned int size,
+                        char *filename)
 {
   size_t width, height;
   MagickBooleanType status;
@@ -8185,7 +8185,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
   if (ino < 0 || ino >= MagickGetNumberImages (image_wand))
     {
       image_error ("Invalid image number `%s' in image `%s'",
-		   image, img->spec);
+                   image, img->spec);
       DestroyMagickWand (image_wand);
       return 0;
     }
@@ -8203,9 +8203,9 @@ imagemagick_load_image (struct frame *f, struct image *img,
       MagickWand *super_wand = image_wand;
       image_wand = imagemagick_compute_animated_image (super_wand, ino);
       if (! image_wand)
-	image_wand = super_wand;
+        image_wand = super_wand;
       else
-	DestroyMagickWand (super_wand);
+        DestroyMagickWand (super_wand);
     }
 
   /* Retrieve the frame's background color, for use later.  */
@@ -8215,7 +8215,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
     specified_bg = image_spec_value (img->spec, QCbackground, NULL);
     if (!STRINGP (specified_bg)
-	|| !x_defined_color (f, SSDATA (specified_bg), &bgcolor, 0))
+        || !x_defined_color (f, SSDATA (specified_bg), &bgcolor, 0))
       x_query_frame_background_color (f, &bgcolor);
 
     bg_wand = NewPixelWand ();
@@ -8225,18 +8225,18 @@ imagemagick_load_image (struct frame *f, struct image *img,
   }
 
   compute_image_size (MagickGetImageWidth (image_wand),
-		      MagickGetImageHeight (image_wand),
-		      img->spec, &desired_width, &desired_height);
+                      MagickGetImageHeight (image_wand),
+                      img->spec, &desired_width, &desired_height);
 
   if (desired_width != -1 && desired_height != -1)
     {
       status = MagickScaleImage (image_wand, desired_width, desired_height);
       if (status == MagickFalse)
-	{
-	  image_error ("Imagemagick scale failed", Qnil, Qnil);
-	  imagemagick_error (image_wand);
-	  goto imagemagick_error;
-	}
+        {
+          image_error ("Imagemagick scale failed", Qnil, Qnil);
+          imagemagick_error (image_wand);
+          goto imagemagick_error;
+        }
     }
 
   /* crop behaves similar to image slicing in Emacs but is more memory
@@ -8253,21 +8253,21 @@ imagemagick_load_image (struct frame *f, struct image *img,
       size_t crop_width = XINT (XCAR (crop));
       crop = XCDR (crop);
       if (CONSP (crop) && TYPE_RANGED_INTEGERP (size_t, XCAR (crop)))
-	{
-	  size_t crop_height = XINT (XCAR (crop));
-	  crop = XCDR (crop);
-	  if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
-	    {
-	      ssize_t crop_x = XINT (XCAR (crop));
-	      crop = XCDR (crop);
-	      if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
-		{
-		  ssize_t crop_y = XINT (XCAR (crop));
-		  MagickCropImage (image_wand, crop_width, crop_height,
-				   crop_x, crop_y);
-		}
-	    }
-	}
+        {
+          size_t crop_height = XINT (XCAR (crop));
+          crop = XCDR (crop);
+          if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
+            {
+              ssize_t crop_x = XINT (XCAR (crop));
+              crop = XCDR (crop);
+              if (CONSP (crop) && TYPE_RANGED_INTEGERP (ssize_t, XCAR (crop)))
+                {
+                  ssize_t crop_y = XINT (XCAR (crop));
+                  MagickCropImage (image_wand, crop_width, crop_height,
+                                   crop_x, crop_y);
+                }
+            }
+        }
     }
 
   /* Furthermore :rotation. we need background color and angle for
@@ -8284,7 +8284,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
       if (status == MagickFalse)
         {
           image_error ("Imagemagick image rotate failed", Qnil, Qnil);
-	  imagemagick_error (image_wand);
+          imagemagick_error (image_wand);
           goto imagemagick_error;
         }
     }
@@ -8311,7 +8311,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
   width = MagickGetImageWidth (image_wand);
 
   if (! (width <= INT_MAX && height <= INT_MAX
-	 && check_image_size (f, width, height)))
+         && check_image_size (f, width, height)))
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       goto imagemagick_error;
@@ -8332,14 +8332,14 @@ imagemagick_load_image (struct frame *f, struct image *img,
       const char *exportdepth = imagedepth <= 8 ? "I" : "BGRP"; /*"RGBP";*/
       /* Try to create a x pixmap to hold the imagemagick pixmap.  */
       if (!image_create_x_image_and_pixmap (f, img, width, height, imagedepth,
-					    &ximg, 0))
-	{
+                                            &ximg, 0))
+        {
 #ifdef COLOR_TABLE_SUPPORT
-	  free_color_table ();
+          free_color_table ();
 #endif
-	  image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
-	  goto imagemagick_error;
-	}
+          image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
+          goto imagemagick_error;
+        }
 
       /* Oddly, the below code doesn't seem to work:*/
       /* switch(ximg->bitmap_unit){ */
@@ -8362,7 +8362,7 @@ imagemagick_load_image (struct frame *f, struct image *img,
       */
       pixelwidth = CharPixel; /*??? TODO figure out*/
       MagickExportImagePixels (image_wand, 0, 0, width, height,
-			       exportdepth, pixelwidth, ximg->data);
+                               exportdepth, pixelwidth, ximg->data);
     }
   else
 #endif /* HAVE_MAGICKEXPORTIMAGEPIXELS */
@@ -8371,10 +8371,10 @@ imagemagick_load_image (struct frame *f, struct image *img,
 
       /* Try to create a x pixmap to hold the imagemagick pixmap.  */
       if (!image_create_x_image_and_pixmap (f, img, width, height, 0,
-					    &ximg, 0))
+                                            &ximg, 0))
         {
 #ifdef COLOR_TABLE_SUPPORT
-	  free_color_table ();
+          free_color_table ();
 #endif
           image_error ("Imagemagick X bitmap allocation failure", Qnil, Qnil);
           goto imagemagick_error;
@@ -8389,9 +8389,9 @@ imagemagick_load_image (struct frame *f, struct image *img,
       if (! iterator)
         {
 #ifdef COLOR_TABLE_SUPPORT
-	  free_color_table ();
+          free_color_table ();
 #endif
-	  x_destroy_x_image (ximg);
+          x_destroy_x_image (ximg);
           image_error ("Imagemagick pixel iterator creation failed",
                        Qnil, Qnil);
           goto imagemagick_error;
@@ -8466,10 +8466,10 @@ imagemagick_load (struct frame *f, struct image *img)
 
       file = x_find_image_file (file_name);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", file_name, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", file_name, Qnil);
+          return 0;
+        }
 #ifdef WINDOWSNT
       file = ansi_encode_filename (file);
 #endif
@@ -8483,10 +8483,10 @@ imagemagick_load (struct frame *f, struct image *img)
 
       data = image_spec_value (img->spec, QCdata, NULL);
       if (!STRINGP (data))
-	{
-	  image_error ("Invalid image data `%s'", data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       success_p = imagemagick_load_image (f, img, SDATA (data),
                                           SBYTES (data), NULL);
     }
@@ -8533,7 +8533,7 @@ and `imagemagick-types-inhibit'.  */)
 
 
 /***********************************************************************
-				 SVG
+                                 SVG
  ***********************************************************************/
 
 #if defined (HAVE_RSVG)
@@ -8544,7 +8544,7 @@ static bool svg_image_p (Lisp_Object object);
 static bool svg_load (struct frame *f, struct image *img);
 
 static bool svg_load_image (struct frame *, struct image *,
-			    unsigned char *, ptrdiff_t);
+                            unsigned char *, ptrdiff_t);
 
 /* The symbol `svg' identifying images of this type. */
 
@@ -8699,13 +8699,13 @@ init_svg_functions (void)
 #define fn_rsvg_handle_close		rsvg_handle_close
 #define fn_rsvg_handle_get_pixbuf	rsvg_handle_get_pixbuf
 
-#define fn_gdk_pixbuf_get_width		  gdk_pixbuf_get_width
-#define fn_gdk_pixbuf_get_height	  gdk_pixbuf_get_height
-#define fn_gdk_pixbuf_get_pixels	  gdk_pixbuf_get_pixels
-#define fn_gdk_pixbuf_get_rowstride	  gdk_pixbuf_get_rowstride
-#define fn_gdk_pixbuf_get_colorspace	  gdk_pixbuf_get_colorspace
-#define fn_gdk_pixbuf_get_n_channels	  gdk_pixbuf_get_n_channels
-#define fn_gdk_pixbuf_get_has_alpha	  gdk_pixbuf_get_has_alpha
+#define fn_gdk_pixbuf_get_width           gdk_pixbuf_get_width
+#define fn_gdk_pixbuf_get_height          gdk_pixbuf_get_height
+#define fn_gdk_pixbuf_get_pixels          gdk_pixbuf_get_pixels
+#define fn_gdk_pixbuf_get_rowstride       gdk_pixbuf_get_rowstride
+#define fn_gdk_pixbuf_get_colorspace      gdk_pixbuf_get_colorspace
+#define fn_gdk_pixbuf_get_n_channels      gdk_pixbuf_get_n_channels
+#define fn_gdk_pixbuf_get_has_alpha       gdk_pixbuf_get_has_alpha
 #define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
 
 #if ! GLIB_CHECK_VERSION (2, 36, 0)
@@ -8734,18 +8734,18 @@ svg_load (struct frame *f, struct image *img)
 
       file = x_find_image_file (file_name);
       if (!STRINGP (file))
-	{
-	  image_error ("Cannot find image file `%s'", file_name, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Cannot find image file `%s'", file_name, Qnil);
+          return 0;
+        }
 
       /* Read the entire file into memory.  */
       contents = slurp_file (SSDATA (file), &size);
       if (contents == NULL)
-	{
-	  image_error ("Error loading SVG image `%s'", img->spec, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Error loading SVG image `%s'", img->spec, Qnil);
+          return 0;
+        }
       /* If the file was slurped into memory properly, parse it.  */
       success_p = svg_load_image (f, img, contents, size);
       xfree (contents);
@@ -8758,10 +8758,10 @@ svg_load (struct frame *f, struct image *img)
 
       data = image_spec_value (img->spec, QCdata, NULL);
       if (!STRINGP (data))
-	{
-	  image_error ("Invalid image data `%s'", data, Qnil);
-	  return 0;
-	}
+        {
+          image_error ("Invalid image data `%s'", data, Qnil);
+          return 0;
+        }
       success_p = svg_load_image (f, img, SDATA (data), SBYTES (data));
     }
 
@@ -8777,9 +8777,9 @@ svg_load (struct frame *f, struct image *img)
    Returns true when successful.  */
 static bool
 svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  */
-		struct image *img,       /* Pointer to emacs image structure.  */
-		unsigned char *contents, /* String containing the SVG XML data to be parsed.  */
-		ptrdiff_t size)          /* Size of data in bytes.  */
+                struct image *img,       /* Pointer to emacs image structure.  */
+                unsigned char *contents, /* String containing the SVG XML data to be parsed.  */
+                ptrdiff_t size)          /* Size of data in bytes.  */
 {
   RsvgHandle *rsvg_handle;
   RsvgDimensionData dimension_data;
@@ -8868,26 +8868,26 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
   for (y = 0; y < height; ++y)
     {
       for (x = 0; x < width; ++x)
-	{
-	  int red;
-	  int green;
-	  int blue;
-	  int opacity;
-
-	  red     = *pixels++;
-	  green   = *pixels++;
-	  blue    = *pixels++;
-	  opacity = *pixels++;
-
-	  red   = ((red * opacity)
-		   + (background.red * ((1 << 8) - opacity)));
-	  green = ((green * opacity)
-		   + (background.green * ((1 << 8) - opacity)));
-	  blue  = ((blue * opacity)
-		   + (background.blue * ((1 << 8) - opacity)));
-
-	  XPutPixel (ximg, x, y, lookup_rgb_color (f, red, green, blue));
-	}
+        {
+          int red;
+          int green;
+          int blue;
+          int opacity;
+
+          red     = *pixels++;
+          green   = *pixels++;
+          blue    = *pixels++;
+          opacity = *pixels++;
+
+          red   = ((red * opacity)
+                   + (background.red * ((1 << 8) - opacity)));
+          green = ((green * opacity)
+                   + (background.green * ((1 << 8) - opacity)));
+          blue  = ((blue * opacity)
+                   + (background.blue * ((1 << 8) - opacity)));
+
+          XPutPixel (ximg, x, y, lookup_rgb_color (f, red, green, blue));
+        }
 
       pixels += rowstride - 4 * width;
     }
@@ -8927,7 +8927,7 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
 
 
 /***********************************************************************
-				Ghostscript
+                                Ghostscript
  ***********************************************************************/
 
 #ifdef HAVE_X_WINDOWS
@@ -9026,18 +9026,18 @@ gs_image_p (Lisp_Object object)
   if (CONSP (tem))
     {
       for (i = 0; i < 4; ++i, tem = XCDR (tem))
-	if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
-	  return 0;
+        if (!CONSP (tem) || !INTEGERP (XCAR (tem)))
+          return 0;
       if (!NILP (tem))
-	return 0;
+        return 0;
     }
   else if (VECTORP (tem))
     {
       if (ASIZE (tem) != 4)
-	return 0;
+        return 0;
       for (i = 0; i < 4; ++i)
-	if (!INTEGERP (AREF (tem, i)))
-	  return 0;
+        if (!INTEGERP (AREF (tem, i)))
+          return 0;
     }
   else
     return 0;
@@ -9071,7 +9071,7 @@ gs_load (struct frame *f, struct image *img)
   in_height *= FRAME_RES_Y (f);
 
   if (! (in_width <= INT_MAX && in_height <= INT_MAX
-	 && check_image_size (f, in_width, in_height)))
+         && check_image_size (f, in_width, in_height)))
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
       return 0;
@@ -9087,8 +9087,8 @@ gs_load (struct frame *f, struct image *img)
       /* Only W32 version did BLOCK_INPUT here.  ++kfs */
       block_input ();
       img->pixmap = XCreatePixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-				   img->width, img->height,
-				   DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
+                                   img->width, img->height,
+                                   DefaultDepthOfScreen (FRAME_X_SCREEN (f)));
       unblock_input ();
     }
 
@@ -9118,10 +9118,10 @@ gs_load (struct frame *f, struct image *img)
     loader = intern ("gs-load-image");
 
   img->lisp_data = call6 (loader, frame, img->spec,
-			  make_number (img->width),
-			  make_number (img->height),
-			  window_and_pixmap_id,
-			  pixel_colors);
+                          make_number (img->width),
+                          make_number (img->height),
+                          window_and_pixmap_id,
+                          pixel_colors);
   return PROCESSP (img->lisp_data);
 }
 
@@ -9169,44 +9169,44 @@ x_kill_gs_process (Pixmap pixmap, struct frame *f)
 
       /* Try to get an XImage for img->pixmep.  */
       ximg = XGetImage (FRAME_X_DISPLAY (f), img->pixmap,
-			0, 0, img->width, img->height, ~0, ZPixmap);
+                        0, 0, img->width, img->height, ~0, ZPixmap);
       if (ximg)
-	{
-	  int x, y;
-
-	  /* Initialize the color table.  */
-	  init_color_table ();
-
-	  /* For each pixel of the image, look its color up in the
-	     color table.  After having done so, the color table will
-	     contain an entry for each color used by the image.  */
-	  for (y = 0; y < img->height; ++y)
-	    for (x = 0; x < img->width; ++x)
-	      {
-		unsigned long pixel = XGetPixel (ximg, x, y);
-		lookup_pixel_color (f, pixel);
-	      }
-
-	  /* Record colors in the image.  Free color table and XImage.  */
+        {
+          int x, y;
+
+          /* Initialize the color table.  */
+          init_color_table ();
+
+          /* For each pixel of the image, look its color up in the
+             color table.  After having done so, the color table will
+             contain an entry for each color used by the image.  */
+          for (y = 0; y < img->height; ++y)
+            for (x = 0; x < img->width; ++x)
+              {
+                unsigned long pixel = XGetPixel (ximg, x, y);
+                lookup_pixel_color (f, pixel);
+              }
+
+          /* Record colors in the image.  Free color table and XImage.  */
 #ifdef COLOR_TABLE_SUPPORT
-	  img->colors = colors_in_color_table (&img->ncolors);
-	  free_color_table ();
+          img->colors = colors_in_color_table (&img->ncolors);
+          free_color_table ();
 #endif
-	  XDestroyImage (ximg);
+          XDestroyImage (ximg);
 
 #if 0 /* This doesn't seem to be the case.  If we free the colors
-	 here, we get a BadAccess later in x_clear_image when
-	 freeing the colors.  */
-	  /* We have allocated colors once, but Ghostscript has also
-	     allocated colors on behalf of us.  So, to get the
-	     reference counts right, free them once.  */
-	  if (img->ncolors)
-	    x_free_colors (f, img->colors, img->ncolors);
+         here, we get a BadAccess later in x_clear_image when
+         freeing the colors.  */
+          /* We have allocated colors once, but Ghostscript has also
+             allocated colors on behalf of us.  So, to get the
+             reference counts right, free them once.  */
+          if (img->ncolors)
+            x_free_colors (f, img->colors, img->ncolors);
 #endif
-	}
+        }
       else
-	image_error ("Cannot get X image of `%s'; colors will not be freed",
-		     img->spec, Qnil);
+        image_error ("Cannot get X image of `%s'; colors will not be freed",
+                     img->spec, Qnil);
 
       unblock_input ();
     }
@@ -9223,7 +9223,7 @@ x_kill_gs_process (Pixmap pixmap, struct frame *f)
 
 
 /***********************************************************************
-				Tests
+                                Tests
  ***********************************************************************/
 
 #ifdef GLYPH_DEBUG
@@ -9252,7 +9252,7 @@ DEFUN ("lookup-image", Flookup_image, Slookup_image, 1, 1, 0, "")
 
 
 /***********************************************************************
-			    Initialization
+                            Initialization
  ***********************************************************************/
 
 DEFUN ("init-image-library", Finit_image_library, Sinit_image_library, 1, 1, 0,
@@ -9401,29 +9401,29 @@ non-numeric, there is no explicit limit on the size of images.  */);
   DEFSYM (Qlibpng_version, "libpng-version");
   Fset (Qlibpng_version,
 #if HAVE_PNG
-	make_number (PNG_LIBPNG_VER)
+        make_number (PNG_LIBPNG_VER)
 #else
-	make_number (-1)
+        make_number (-1)
 #endif
-	);
+        );
   DEFSYM (Qlibgif_version, "libgif-version");
   Fset (Qlibgif_version,
 #ifdef HAVE_GIF
-	make_number (GIFLIB_MAJOR * 10000
-		     + GIFLIB_MINOR * 100
-		     + GIFLIB_RELEASE)
+        make_number (GIFLIB_MAJOR * 10000
+                     + GIFLIB_MINOR * 100
+                     + GIFLIB_RELEASE)
 #else
-	make_number (-1)
+        make_number (-1)
 #endif
         );
   DEFSYM (Qlibjpeg_version, "libjpeg-version");
   Fset (Qlibjpeg_version,
 #if HAVE_JPEG
-	make_number (JPEG_LIB_VERSION)
+        make_number (JPEG_LIB_VERSION)
 #else
-	make_number (-1)
+        make_number (-1)
 #endif
-	);
+        );
 #endif
 
   DEFSYM (Qpbm, "pbm");
-- 
1.9.0

