Index: gimp/app/paint/Makefile.am
===================================================================
RCS file: /cvs/gnome/gimp/app/paint/Makefile.am,v
retrieving revision 1.28
diff -u -p -r1.28 Makefile.am
--- gimp/app/paint/Makefile.am	13 Feb 2005 15:08:05 -0000	1.28
+++ gimp/app/paint/Makefile.am	4 Aug 2006 15:50:14 -0000
@@ -42,6 +42,10 @@ libapppaint_a_sources = \
 	gimperaser.h		\
 	gimperaseroptions.c	\
 	gimperaseroptions.h	\
+	gimpheal.c	\
+	gimpheal.h	\
+	gimphealoptions.c	\
+	gimphealoptions.h	\
 	gimpink.c		\
 	gimpink.h		\
 	gimpink-blob.c		\
Index: gimp/app/paint/gimp-paint.c
===================================================================
RCS file: /cvs/gnome/gimp/app/paint/gimp-paint.c,v
retrieving revision 1.8
diff -u -p -r1.8 gimp-paint.c
--- gimp/app/paint/gimp-paint.c	7 Apr 2006 10:51:21 -0000	1.8
+++ gimp/app/paint/gimp-paint.c	4 Aug 2006 15:50:14 -0000
@@ -32,6 +32,7 @@
 #include "gimpconvolve.h"
 #include "gimpdodgeburn.h"
 #include "gimperaser.h"
+#include "gimpheal.h"
 #include "gimpink.h"
 #include "gimppaintoptions.h"
 #include "gimppaintbrush.h"
@@ -60,6 +61,7 @@ gimp_paint_init (Gimp *gimp)
     gimp_smudge_register,
     gimp_convolve_register,
     gimp_clone_register,
+    gimp_heal_register,
     gimp_ink_register,
     gimp_airbrush_register,
     gimp_eraser_register,
Index: gimp/app/paint/gimpbrushcore.c
===================================================================
RCS file: /cvs/gnome/gimp/app/paint/gimpbrushcore.c,v
retrieving revision 1.24
diff -u -p -r1.24 gimpbrushcore.c
--- gimp/app/paint/gimpbrushcore.c	15 May 2006 09:46:16 -0000	1.24
+++ gimp/app/paint/gimpbrushcore.c	4 Aug 2006 15:50:15 -0000
@@ -727,9 +727,9 @@ gimp_brush_core_set_brush (GimpBrushCore
 
 void
 gimp_brush_core_paste_canvas (GimpBrushCore            *core,
-                              GimpDrawable               *drawable,
-                              gdouble                        brush_opacity,
-                              gdouble                        image_opacity,
+                              GimpDrawable             *drawable,
+                              gdouble                   brush_opacity,
+                              gdouble                   image_opacity,
                               GimpLayerModeEffects      paint_mode,
                               GimpBrushApplicationMode  brush_hardness,
                               GimpPaintApplicationMode  mode)
Index: gimp/app/paint/gimpheal.c
===================================================================
RCS file: gimp/app/paint/gimpheal.c
diff -N gimp/app/paint/gimpheal.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/paint/gimpheal.c	4 Aug 2006 15:50:16 -0000
@@ -0,0 +1,597 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib-object.h>
+
+#include "libgimpbase/gimpbase.h"
+
+#include "paint-types.h"
+
+#include "base/pixel-region.h"
+#include "base/temp-buf.h"
+#include "base/tile-manager.h"
+
+#include "core/gimpitem.h"
+#include "core/gimppickable.h"
+#include "core/gimpimage.h"
+#include "core/gimpdrawable.h"
+#include "core/gimppattern.h"
+
+#include "gimpheal.h"
+#include "gimphealoptions.h"
+
+#include "gimp-intl.h"
+
+#define EPSILON 0.00001
+
+enum
+{
+  PROP_0,
+  PROP_SRC_DRAWABLE,
+  PROP_SRC_X,
+  PROP_SRC_Y
+};
+
+static void   gimp_heal_set_property     (GObject          *object,
+                                          guint             property_id,
+                                          const GValue     *value,
+                                          GParamSpec       *pspec);
+static void   gimp_heal_get_property     (GObject          *object,
+                                          guint             property_id,
+                                          GValue           *value,
+                                          GParamSpec       *pspec);
+
+static void   gimp_heal_paint            (GimpPaintCore    *paint_core,
+                                          GimpDrawable     *drawable,
+                                          GimpPaintOptions *paint_options,
+                                          GimpPaintState    paint_state,
+                                          guint32           time);
+static void   gimp_heal_motion           (GimpPaintCore    *paint_core,
+                                          GimpDrawable     *drawable,
+                                          GimpPaintOptions *paint_options);
+
+static void   gimp_heal_set_src_drawable (GimpHeal         *heal,
+                                          GimpDrawable     *drawable);
+
+G_DEFINE_TYPE (GimpHeal, gimp_heal, GIMP_TYPE_BRUSH_CORE)
+
+void
+gimp_heal_register (Gimp                      *gimp,
+                    GimpPaintRegisterCallback  callback)
+{
+  (* callback) (gimp,                    /* gimp */
+                GIMP_TYPE_HEAL,          /* paint type */
+                GIMP_TYPE_HEAL_OPTIONS,  /* paint options type */
+                "gimp-heal",             /* identifier */
+                _("Heal"),               /* blurb */
+                "gimp-tool-heal");       /* stock id */
+}
+
+static void
+gimp_heal_class_init (GimpHealClass *klass)
+{
+  GObjectClass       *object_class     = G_OBJECT_CLASS (klass);
+  GimpPaintCoreClass *paint_core_class = GIMP_PAINT_CORE_CLASS (klass);
+  GimpBrushCoreClass *brush_core_class = GIMP_BRUSH_CORE_CLASS (klass);
+
+  object_class->set_property           = gimp_heal_set_property;
+  object_class->get_property           = gimp_heal_get_property;
+
+  paint_core_class->paint              = gimp_heal_paint;
+
+  brush_core_class->handles_changing_brush = TRUE;
+
+  g_object_class_install_property (object_class, PROP_SRC_DRAWABLE,
+                                   g_param_spec_object ("src-drawable",
+                                                        NULL, NULL,
+                                                        GIMP_TYPE_DRAWABLE,
+                                                        GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_SRC_X,
+                                   g_param_spec_double ("src-x", NULL, NULL,
+                                                        0, GIMP_MAX_IMAGE_SIZE,
+                                                        0.0,
+                                                        GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_SRC_Y,
+                                   g_param_spec_double ("src-y", NULL, NULL,
+                                                        0, GIMP_MAX_IMAGE_SIZE,
+                                                        0.0,
+                                                        GIMP_PARAM_READWRITE));
+}
+
+static void
+gimp_heal_init (GimpHeal *heal)
+{
+  heal->set_source   = FALSE;
+
+  heal->src_drawable = NULL;
+  heal->src_x        = 0.0;
+  heal->src_y        = 0.0;
+
+  heal->offset_x     = 0.0;
+  heal->offset_y     = 0.0;
+  heal->first_stroke = TRUE;
+}
+
+static void
+gimp_heal_set_property (GObject      *object,
+                        guint         property_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  GimpHeal *heal = GIMP_HEAL (object);
+
+  switch (property_id)
+    {
+    case PROP_SRC_DRAWABLE:
+      gimp_heal_set_src_drawable (heal, g_value_get_object (value));
+      break;
+    case PROP_SRC_X:
+      heal->src_x = g_value_get_double (value);
+      break;
+    case PROP_SRC_Y:
+      heal->src_y = g_value_get_double (value);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_heal_get_property (GObject    *object,
+                        guint       property_id,
+                        GValue     *value,
+                        GParamSpec *pspec)
+{
+  GimpHeal *heal = GIMP_HEAL (object);
+
+  switch (property_id)
+    {
+    case PROP_SRC_DRAWABLE:
+      g_value_set_object (value, heal->src_drawable);
+      break;
+    case PROP_SRC_X:
+      g_value_set_int (value, heal->src_x);
+      break;
+    case PROP_SRC_Y:
+      g_value_set_int (value, heal->src_y);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_heal_paint (GimpPaintCore    *paint_core,
+                 GimpDrawable     *drawable,
+                 GimpPaintOptions *paint_options,
+                 GimpPaintState    paint_state,
+                 guint32           time)
+{
+  GimpHeal        *heal = GIMP_HEAL (paint_core);
+
+  /* gimp passes the current state of the painting system to the function */
+  switch (paint_state)
+    {
+    case GIMP_PAINT_STATE_INIT:
+      /* heal->set_source is set by gimphealtool when CTRL is pressed */
+      if (heal->set_source)
+        {
+          /* defined later in this file, sets heal to the current drawable
+           * and notifies heal that the drawable is ready */
+          gimp_heal_set_src_drawable (heal, drawable);
+
+          /* get the current source coordinates from the paint core */
+          heal->src_x = paint_core->cur_coords.x;
+          heal->src_y = paint_core->cur_coords.y;
+
+          /* set first stroke to be true */
+          heal->first_stroke = TRUE;
+        }
+      break;
+
+    case GIMP_PAINT_STATE_MOTION:
+      if (heal->set_source)
+        {
+          /*  if the control key is down, move the src and return */
+          heal->src_x = paint_core->cur_coords.x;
+          heal->src_y = paint_core->cur_coords.y;
+
+          heal->first_stroke = TRUE;
+        }
+      else
+        {
+          /*  otherwise, update the target  */
+
+          /* get the current destination from the paint core */
+          gint dest_x = paint_core->cur_coords.x;
+          gint dest_y = paint_core->cur_coords.y;
+
+          /* if this is the first stroke, record the offset of the destination
+           * relative to the source */
+          if (heal->first_stroke)
+            {
+              heal->offset_x = heal->src_x - dest_x;
+              heal->offset_y = heal->src_y - dest_y;
+              
+              heal->first_stroke = FALSE;
+            }
+
+          /* if this is not the first stroke, set the source as 
+           * destination + offset */
+          heal->src_x = dest_x + heal->offset_x;
+          heal->src_y = dest_y + heal->offset_y;
+
+          /* defined later, does the actual cloning */
+          gimp_heal_motion (paint_core, drawable, paint_options);
+        }
+      break;
+
+    default:
+      break;
+    }
+
+  /* notify the brush that the src attributes have changed */
+  g_object_notify (G_OBJECT (heal), "src-x");
+  g_object_notify (G_OBJECT (heal), "src-y");
+}
+
+void 
+gimp_heal_divide_matrix (guchar  *top, 
+                         guchar  *bottom, 
+                         gint     width, 
+                         gint     height,
+                         gint     depth,
+                         gint     t_rowstride,
+                         gint     b_rowstride,
+                         gdouble *result)
+{
+  gint i, j, k;
+  guchar *t, *b;
+
+  for (i = 0; i < height; i++) 
+    {
+      t = top;
+      b = bottom;
+
+      for (j = 0; j < width; j++)
+        {
+          for (k = 0; k < depth; k++)
+            {
+              if (b[k] == 0)
+                result[k] = (gdouble) 255.0;
+              else
+                result[k] = (gdouble) (t[k]) / (gdouble) (b[k]);
+            }
+
+          t       += depth;
+          b       += depth;
+          result  += depth;
+        }
+
+      top    += t_rowstride;
+      bottom += b_rowstride;
+    }
+}
+
+void 
+gimp_heal_multiply_matrix (gdouble *first, 
+                           guchar  *second, 
+                           gint     width, 
+                           gint     height, 
+                           gint     depth,
+                           gint     s_rowstride,
+                           gint     r_rowstride,
+                           guchar  *result)
+{
+  gint i, j, k;
+  gdouble *f;
+  guchar  *s, *r;
+  for (i = 0; i < height; i++) 
+    {
+      f = first;
+      s = second;
+      r = result;
+
+      for (j = 0; j < width; j++)
+        {
+          for (k = 0; k < depth; k++)
+            r[k] = (guchar) CLAMP0255 (ROUND (((gdouble) (f[k])) * ((gdouble) (s[k]))));
+
+          f       += depth;
+          s       += depth;
+          r       += depth;
+        }
+
+      second += s_rowstride;
+      result += r_rowstride;
+    }
+}
+
+gboolean 
+gimp_heal_laplace_iteration (gdouble *matrix,
+                             gint     width, 
+                             gint     height, 
+                             gint     depth,
+                             gdouble *solution)
+{
+  gint i, j, k;
+  gint rowstride = width * depth;
+  gboolean done = TRUE;
+
+  for (i = 0; i < height; i++) 
+    {
+      for (j = 0; j < width; j++) 
+        {
+          if ((i == 0) || (i == (height - 1)) || (j == 0) || (j == (height - 1)))
+            /* do nothing at the boundary */
+            for (k = 0; k < depth; k++) 
+              *(solution + k) = *(matrix + k);
+          else
+            {
+              /* calculate the mean of four neighbours for all color channels */
+              /* v[i][j] = 0.45 * (v[i][j-1]+v[i][j+1]+v[i-1][j]+v[i+1][j]) */
+              for (k = 0; k < depth; k++)
+                {
+                  *(solution + k) = 0.25 * 
+                                    ( *(matrix - depth + k)       /* west */
+                                    + *(matrix + depth + k)       /* east */
+                                    + *(matrix - rowstride + k)   /* north */
+                                    + *(matrix + rowstride + k)); /* south */
+
+                  /* if any value changes more than EPSILON, we have not 
+                   * converged */
+                  /* FIXME: This convergence test isn't working, it converges
+                   * way too fast.
+                  if (abs (*(solution + k) - *(matrix + k)) > EPSILON)
+                    done = FALSE;
+                  */
+                }
+
+            }
+
+          /* advance pointers to data */
+          matrix += depth; solution += depth;
+        }
+    }
+
+  return done;
+}
+
+void 
+gimp_heal_laplace_solver (gdouble *matrix, 
+                          gint     width, 
+                          gint     height, 
+                          gint     depth,
+                          gdouble *solution)
+{
+  gint num_iter = 150;
+  while (num_iter--) 
+    {
+      /* heal the region */
+      gimp_heal_laplace_iteration (matrix, width, height, depth, solution);
+
+      /* copy solution to matrix */
+      memcpy (matrix, solution, width * height * depth * sizeof(double));
+    }
+}
+
+static void
+gimp_heal_motion (GimpPaintCore    *paint_core,
+                  GimpDrawable     *drawable,
+                  GimpPaintOptions *paint_options)
+{
+  GimpHeal            *heal             = GIMP_HEAL (paint_core);
+  GimpContext         *context          = GIMP_CONTEXT (paint_options);
+  GimpPressureOptions *pressure_options = paint_options->pressure_options;
+  GimpImage           *image;
+  GimpImage           *src_image        = NULL;
+  GimpPickable        *src_pickable     = NULL;
+  TempBuf             *area;
+  gpointer             pr               = NULL;
+  gint                 x1, y1, x2, y2;
+  TileManager         *src_tiles;
+  gdouble              opacity;
+  gint                 offset_x;
+  gint                 offset_y;
+  gint                 width, height, depth;      
+
+  PixelRegion          fPR, gPR, hPR;
+  guchar              *f, *g, *h;
+  gdouble             *i_1, *i_2;
+
+  /* get the image */
+  image = gimp_item_get_image (GIMP_ITEM (drawable));
+
+  /* get the opacity of the image */
+  opacity = gimp_paint_options_get_fade (paint_options, image,
+                                         paint_core->pixel_dist);
+
+  /* opacity is zero implies that we can't see the brush anywas so do nothing */
+  if (opacity == 0.0)
+    return;
+
+  /*  make local copies because we change them  */
+  offset_x = heal->offset_x;
+  offset_y = heal->offset_y;
+
+  /* make sure our source drawable is valid */
+  if (! heal->src_drawable)
+    return;
+
+  /* cast the drawable region to a pickable object */
+  src_pickable = GIMP_PICKABLE (heal->src_drawable);
+
+  /* get the image data from the pickable object */
+  src_image = gimp_pickable_get_image (src_pickable);
+
+  /* get the paint area */
+  area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options);
+  if (! area)
+    return;
+
+  /* fPR will be the pixels under the current painthit from the drawable */
+  pixel_region_init (&fPR, gimp_drawable_get_tiles (drawable),
+                     area->x, area->y, area->width, area->height, FALSE);
+
+  /* hPR will be the same as fPR but we can edit it */
+  pixel_region_init (&hPR, gimp_drawable_get_tiles (drawable),
+                     area->x, area->y, area->width, area->height, TRUE);
+
+  /* store the width, height, and depth for later */
+  width  = fPR.w;
+  height = fPR.h;
+  depth  = fPR.bytes;
+
+  /* set the paint area to transparent */
+  temp_buf_data_clear (area);
+
+  /* get the source tiles from the pickable */
+  src_tiles = gimp_pickable_get_tiles (src_pickable);
+
+  /* get a copy of the location we will sample from */
+  {
+    x1 = CLAMP (area->x + offset_x, 0, tile_manager_width  (src_tiles));
+    y1 = CLAMP (area->y + offset_y, 0, tile_manager_height (src_tiles));
+    x2 = CLAMP (area->x + offset_x + area->width, 0, tile_manager_width  (src_tiles));
+    y2 = CLAMP (area->y + offset_y + area->height, 0, tile_manager_height (src_tiles));
+    
+    if (!(x2 - x1) || !(y2 - y1))
+      return;
+
+    /*  if the source image is different from the destination,
+     *  then we should copy straight from the destination image
+     *  to the canvas.
+     */
+    if (heal->src_drawable != drawable)
+      {
+        /* copy to the source pixel region directly from the source tiles */
+        pixel_region_init (&gPR, src_tiles, x1, y1, x2 - x1, y2 - y1, FALSE);
+      }
+    /*  otherwise, we need a call to get_orig_image to make sure
+     *  we get a copy of the unblemished (offset) image
+     */
+    else
+      {
+        TempBuf *orig;
+
+        /*  get the original image at the sample location */
+        orig = gimp_paint_core_get_orig_image (paint_core,
+                                               GIMP_DRAWABLE (src_pickable),
+                                               x1, y1, x2, y2);
+
+        /* initialize the source region with data from the original image */
+        pixel_region_init_temp_buf (&gPR, orig,
+                                    0, 0, x2 - x1, y2 - y1);
+      }
+  }
+
+  /* allocate memory for the calculations */
+  i_1 = g_malloc (width * height * depth * sizeof (gdouble));
+  i_2 = g_malloc (width * height * depth * sizeof (gdouble));
+
+  for (pr = pixel_regions_register (3, &fPR, &gPR, &hPR); 
+       pr != NULL; 
+       pr = pixel_regions_process (pr));
+    {
+      /* get the region to repair and the sample region */
+      f = fPR.data;
+      g = gPR.data;
+      h = hPR.data;
+
+      /* allocate memory for the calculations */
+      i_1 = g_malloc (width * height * depth * sizeof (gdouble));
+      i_2 = g_malloc (width * height * depth * sizeof (gdouble));
+
+      /* divide f by g to get i_1 */
+      gimp_heal_divide_matrix (f, g, width, height, depth, fPR.rowstride, gPR.rowstride, i_1);
+
+      /* solve the laplace equation */
+      gimp_heal_laplace_solver (i_1, width, height, depth, i_2);
+
+      /* multiply i_2 by g to get h */
+      gimp_heal_multiply_matrix (i_2, g, width, height, depth, gPR.rowstride, hPR.rowstride, h);
+
+      /* free the memory used */
+      g_free (i_1);
+      g_free (i_2);
+  }
+
+  /* calculate the opacity */
+  if (pressure_options->opacity)
+    opacity *= PRESSURE_SCALE * paint_core->cur_coords.pressure;
+
+  /* notify the GIMP system that we want to overlap with a new canvas */
+  gimp_brush_core_paste_canvas (GIMP_BRUSH_CORE (paint_core), drawable,
+                                  MIN (opacity, GIMP_OPACITY_OPAQUE),
+                                  gimp_context_get_opacity (context),
+                                  gimp_context_get_paint_mode (context),
+                                  gimp_paint_options_get_brush_mode (paint_options),
+                                  GIMP_PAINT_CONSTANT);
+}
+
+static void
+gimp_heal_src_drawable_removed (GimpDrawable *drawable,
+                                GimpHeal     *heal)
+{
+  /* set the drawable to NULL */
+  if (drawable == heal->src_drawable)
+    {
+      heal->src_drawable = NULL;
+    }
+
+  /* disconnect the signal handler for this function */
+  g_signal_handlers_disconnect_by_func (drawable,
+                                        gimp_heal_src_drawable_removed,
+                                        heal);
+}
+
+static void
+gimp_heal_set_src_drawable (GimpHeal     *heal,
+                            GimpDrawable *drawable)
+{
+  /* check if we already have a drawable */
+  if (heal->src_drawable == drawable)
+    return;
+
+  /* remove the current signal handler */
+  if (heal->src_drawable)
+    g_signal_handlers_disconnect_by_func (heal->src_drawable,
+                                          gimp_heal_src_drawable_removed,
+                                          heal);
+
+  /* set the drawable */
+  heal->src_drawable = drawable;
+
+  /* connect the signal handler that handles the "remove" signal */
+  if (heal->src_drawable)
+    g_signal_connect (heal->src_drawable, "removed",
+                      G_CALLBACK (gimp_heal_src_drawable_removed),
+                      heal);
+
+  /* notify clone that the source drawable is set */
+  g_object_notify (G_OBJECT (heal), "src-drawable");
+}
Index: gimp/app/paint/gimpheal.h
===================================================================
RCS file: gimp/app/paint/gimpheal.h
diff -N gimp/app/paint/gimpheal.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/paint/gimpheal.h	4 Aug 2006 15:50:16 -0000
@@ -0,0 +1,64 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GIMP_HEAL_H__
+#define __GIMP_HEAL_H__
+
+#include "gimpbrushcore.h"
+
+#define GIMP_TYPE_HEAL            (gimp_heal_get_type ())
+#define GIMP_HEAL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_HEAL, GimpHeal))
+#define GIMP_HEAL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HEAL, GimpHealClass))
+#define GIMP_IS_HEAL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_HEAL))
+#define GIMP_IS_HEAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HEAL))
+#define GIMP_HEAL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_HEAL, GimpHealClass))
+
+typedef struct _GimpHeal      GimpHeal;
+typedef struct _GimpHealClass GimpHealClass;
+
+struct _GimpHeal
+{
+  GimpBrushCore parent_instance;
+
+  gboolean set_source;
+
+  GimpDrawable *src_drawable;
+  gdouble src_x;
+  gdouble src_y;
+
+  gdouble orig_src_x;
+  gdouble orig_src_y;
+
+  gdouble offset_x;
+  gdouble offset_y;
+  gboolean first_stroke;
+};
+
+struct _GimpHealClass
+{
+  GimpBrushCoreClass parent_class;
+};
+
+
+void    gimp_heal_register (Gimp                      *gimp,
+                               GimpPaintRegisterCallback  callback);
+
+GType   gimp_heal_get_type (void) G_GNUC_CONST;
+
+
+#endif  /*  __GIMP_HEAL_H__  */
Index: gimp/app/paint/gimphealoptions.c
===================================================================
RCS file: gimp/app/paint/gimphealoptions.c
diff -N gimp/app/paint/gimphealoptions.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/paint/gimphealoptions.c	4 Aug 2006 15:50:16 -0000
@@ -0,0 +1,67 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <glib-object.h>
+
+#include "libgimpconfig/gimpconfig.h"
+
+#include "paint-types.h"
+#include "gimphealoptions.h"
+
+static void   gimp_heal_options_set_property (GObject      *object,
+                                              guint         property_id,
+                                              const GValue *value,
+                                              GParamSpec   *pspec);
+static void   gimp_heal_options_get_property (GObject      *object,
+                                              guint         property_id,
+                                              GValue       *value,
+                                              GParamSpec   *pspec);
+
+G_DEFINE_TYPE (GimpHealOptions, gimp_heal_options, GIMP_TYPE_PAINT_OPTIONS)
+
+static void
+gimp_heal_options_class_init (GimpHealOptionsClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->set_property = gimp_heal_options_set_property;
+  object_class->get_property = gimp_heal_options_get_property;
+}
+
+static void
+gimp_heal_options_init (GimpHealOptions *options)
+{
+}
+
+static void
+gimp_heal_options_set_property (GObject      *object,
+                                 guint         property_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+}
+
+static void
+gimp_heal_options_get_property (GObject    *object,
+                                 guint       property_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+}
Index: gimp/app/paint/gimphealoptions.h
===================================================================
RCS file: gimp/app/paint/gimphealoptions.h
diff -N gimp/app/paint/gimphealoptions.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/paint/gimphealoptions.h	4 Aug 2006 15:50:16 -0000
@@ -0,0 +1,45 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GIMP_HEAL_OPTIONS_H__
+#define __GIMP_HEAL_OPTIONS_H__
+
+
+#include "gimppaintoptions.h"
+
+
+#define GIMP_TYPE_HEAL_OPTIONS            (gimp_heal_options_get_type ())
+#define GIMP_HEAL_OPTIONS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_HEAL_OPTIONS, GimpHealOptions))
+#define GIMP_HEAL_OPTIONS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HEAL_OPTIONS, GimpHealOptionsClass))
+#define GIMP_IS_HEAL_OPTIONS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_HEAL_OPTIONS))
+#define GIMP_IS_HEAL_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HEAL_OPTIONS))
+#define GIMP_HEAL_OPTIONS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_HEAL_OPTIONS, GimpHealOptionsClass))
+
+
+typedef struct _GimpHealOptions         GimpHealOptions;
+typedef struct _GimpPaintOptionsClass   GimpHealOptionsClass;
+
+struct _GimpHealOptions
+{
+  GimpPaintOptions paint_options;
+};
+  
+
+GType   gimp_heal_options_get_type (void) G_GNUC_CONST;
+
+#endif  /*  __GIMP_HEAL_OPTIONS_H__  */
Index: gimp/app/paint/gimpink.c
===================================================================
RCS file: /cvs/gnome/gimp/app/paint/gimpink.c,v
retrieving revision 1.152
diff -u -p -r1.152 gimpink.c
--- gimp/app/paint/gimpink.c	15 May 2006 09:46:17 -0000	1.152
+++ gimp/app/paint/gimpink.c	4 Aug 2006 15:50:17 -0000
@@ -321,7 +321,7 @@ gimp_ink_motion (GimpPaintCore    *paint
       blob_to_render = blob_union;
     }
 
-  /* Get the the buffer */
+  /* Get the buffer */
   ink->cur_blob = blob_to_render;
   area = gimp_paint_core_get_paint_area (paint_core, drawable, paint_options);
   ink->cur_blob = NULL;
Index: gimp/app/paint/gimpsmudge.c
===================================================================
RCS file: /cvs/gnome/gimp/app/paint/gimpsmudge.c,v
retrieving revision 1.76
diff -u -p -r1.76 gimpsmudge.c
--- gimp/app/paint/gimpsmudge.c	15 May 2006 09:46:17 -0000	1.76
+++ gimp/app/paint/gimpsmudge.c	4 Aug 2006 15:50:17 -0000
@@ -175,6 +175,9 @@ gimp_smudge_start (GimpPaintCore    *pai
   /*  adjust the x and y coordinates to the upper left corner of the brush  */
   gimp_smudge_nonclipped_painthit_coords (paint_core, &x, &y, &w, &h);
 
+  /* srcPR will be the pixels under the current painthit from the drawable */
+  pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
+                     area->x, area->y, area->width, area->height, FALSE);
 
   /*  Allocate the accumulation buffer */
   bytes = gimp_drawable_bytes (drawable);
Index: gimp/app/tools/Makefile.am
===================================================================
RCS file: /cvs/gnome/gimp/app/tools/Makefile.am,v
retrieving revision 1.97
diff -u -p -r1.97 Makefile.am
--- gimp/app/tools/Makefile.am	10 Jun 2006 21:34:12 -0000	1.97
+++ gimp/app/tools/Makefile.am	4 Aug 2006 15:50:17 -0000
@@ -76,6 +76,8 @@ libapptools_a_sources = \
 	gimpforegroundselecttool-undo.h	\
 	gimpfuzzyselecttool.c		\
 	gimpfuzzyselecttool.h		\
+	gimphealtool.c	\
+	gimphealtool.h	\
 	gimphistogramoptions.c		\
 	gimphistogramoptions.h		\
 	gimphuesaturationtool.c		\
Index: gimp/app/tools/gimp-tools.c
===================================================================
RCS file: /cvs/gnome/gimp/app/tools/gimp-tools.c,v
retrieving revision 1.29
diff -u -p -r1.29 gimp-tools.c
--- gimp/app/tools/gimp-tools.c	21 Jun 2006 21:59:03 -0000	1.29
+++ gimp/app/tools/gimp-tools.c	4 Aug 2006 15:50:18 -0000
@@ -62,6 +62,7 @@
 #include "gimpfreeselecttool.h"
 #include "gimpforegroundselecttool.h"
 #include "gimpfuzzyselecttool.h"
+#include "gimphealtool.h"
 #include "gimphuesaturationtool.h"
 #include "gimpinktool.h"
 #include "gimpiscissorstool.h"
@@ -132,6 +133,7 @@ gimp_tools_init (Gimp *gimp)
     gimp_smudge_tool_register,
     gimp_convolve_tool_register,
     gimp_clone_tool_register,
+    gimp_heal_tool_register,
     gimp_ink_tool_register,
     gimp_airbrush_tool_register,
     gimp_eraser_tool_register,
@@ -506,6 +508,10 @@ gimp_tools_register (GType              
   else if (tool_type == GIMP_TYPE_CLONE_TOOL)
     {
       paint_core_name = "gimp-clone";
+    }
+  else if (tool_type == GIMP_TYPE_HEAL_TOOL)
+    {
+      paint_core_name = "gimp-heal";
     }
   else if (tool_type == GIMP_TYPE_CONVOLVE_TOOL)
     {
Index: gimp/app/tools/gimphealtool.c
===================================================================
RCS file: gimp/app/tools/gimphealtool.c
diff -N gimp/app/tools/gimphealtool.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/tools/gimphealtool.c	4 Aug 2006 15:50:18 -0000
@@ -0,0 +1,369 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <gtk/gtk.h>
+
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "tools-types.h"
+
+#include "core/gimpchannel.h"      
+#include "core/gimpimage.h"
+#include "core/gimppickable.h"
+#include "core/gimptoolinfo.h"
+
+#include "paint/gimpheal.h"
+#include "paint/gimphealoptions.h"  
+
+#include "widgets/gimphelp-ids.h"
+#include "widgets/gimpviewablebox.h"
+#include "widgets/gimpwidgets-utils.h"
+
+#include "display/gimpdisplay.h"
+
+#include "gimphealtool.h"
+#include "gimppaintoptions-gui.h"
+#include "gimptoolcontrol.h"
+    
+#include "gimp-intl.h"
+
+#define TARGET_WIDTH  15
+#define TARGET_HEIGHT 15
+
+static void   gimp_heal_tool_button_press  (GimpTool        *tool,
+                                            GimpCoords      *coords,
+                                            guint32          time,
+                                            GdkModifierType  state,
+                                            GimpDisplay     *display);
+
+static void   gimp_heal_tool_motion        (GimpTool        *tool,
+                                            GimpCoords      *coords,
+                                            guint32          time,
+                                            GdkModifierType  state,
+                                            GimpDisplay     *display);
+
+static void   gimp_heal_tool_cursor_update (GimpTool        *tool,
+                                            GimpCoords      *coords,
+                                            GdkModifierType  state,
+                                            GimpDisplay     *display);
+
+static void   gimp_heal_tool_oper_update   (GimpTool        *tool,
+                                            GimpCoords      *coords,
+                                            GdkModifierType  state,
+                                            gboolean         proximity,
+                                            GimpDisplay     *display);
+
+static void   gimp_heal_tool_draw          (GimpDrawTool *draw_tool);
+
+static GtkWidget * gimp_heal_options_gui   (GimpToolOptions *tool_options);
+
+G_DEFINE_TYPE (GimpHealTool, gimp_heal_tool, GIMP_TYPE_PAINT_TOOL)
+
+void
+gimp_heal_tool_register (GimpToolRegisterCallback  callback,
+                         gpointer                  data)
+{
+  (* callback) (GIMP_TYPE_HEAL_TOOL,               /* tool type */
+                GIMP_TYPE_HEAL_OPTIONS,            /* tool option type */
+                gimp_heal_options_gui,             /* options gui */
+                GIMP_PAINT_OPTIONS_CONTEXT_MASK |  /* context properties */
+                GIMP_CONTEXT_PATTERN_MASK,
+                "gimp-heal-tool",                  /* identifier */
+                _("Heal"),                         /* blurb */
+                _("Heal image irregularities"),    /* help */
+                N_("_Heal"),                       /* menu path */
+                "H",                               /* menu accelerator */
+                NULL,                              /* help domain */
+                GIMP_HELP_TOOL_HEAL,               /* help data */
+                GIMP_STOCK_TOOL_HEAL,              /* stock id */
+                data);                             /* register */
+}
+
+static void
+gimp_heal_tool_class_init (GimpHealToolClass *klass)
+{
+  /* get parent classes where we override methods */
+  GimpToolClass     *tool_class      = GIMP_TOOL_CLASS (klass);
+  GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
+
+  /* override the methods */
+  tool_class->button_press  = gimp_heal_tool_button_press;
+  tool_class->motion        = gimp_heal_tool_motion;
+  tool_class->cursor_update = gimp_heal_tool_cursor_update;
+  tool_class->oper_update   = gimp_heal_tool_oper_update;
+
+  draw_tool_class->draw     = gimp_heal_tool_draw;
+}
+
+static void
+gimp_heal_tool_init (GimpHealTool *heal)
+{
+  GimpTool *tool = GIMP_TOOL (heal);
+
+  gimp_tool_control_set_tool_cursor     (tool->control,
+                                         GIMP_TOOL_CURSOR_HEAL);
+
+  gimp_tool_control_set_action_object_2 (tool->control,
+                                         "context/context-pattern-select-set");
+}
+
+static void
+gimp_heal_tool_button_press (GimpTool        *tool,
+                             GimpCoords      *coords,
+                             guint32          time,
+                             GdkModifierType  state,
+                             GimpDisplay     *display)
+{
+  GimpPaintTool   *paint_tool   = GIMP_PAINT_TOOL (tool);
+  GimpHealTool    *heal_tool    = GIMP_HEAL_TOOL (tool);
+  GimpHeal        *heal         = GIMP_HEAL (paint_tool->core);
+
+  /* pause the tool before drawing */
+  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
+
+  /* use_saved_proj tells whether we keep the unmodified pixel projection
+   * around.  in this case no.  */
+  paint_tool->core->use_saved_proj = FALSE;
+
+  /* state holds a set of bit-flags to indicate the state of modifier keys and
+   * mouse buttons in various event types. Typical modifier keys are Shift,
+   * Control, Meta, Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock. 
+   * Part of gtk -> GdkModifierType */
+  if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK) 
+    /* we enter here only if CTRL is pressed */
+    {
+      /* mark that the source display has been set.  defined in gimpheal.h */
+      heal->set_source = TRUE;
+
+      /* if currently active display != the heal tools source display */
+      if (display != heal_tool->src_display)
+        {
+          /* check if the heal tools src display has been previously set */
+          if (heal_tool->src_display)
+            /* if so remove the pointer to the display */
+            g_object_remove_weak_pointer (G_OBJECT (heal_tool->src_display),
+                                          (gpointer *) &heal_tool->src_display);
+
+          /* set the heal tools source display to the currently active
+           * display */
+          heal_tool->src_display = display;
+          /* add a pointer to the display */
+          g_object_add_weak_pointer (G_OBJECT (display),
+                                     (gpointer *) &heal_tool->src_display);
+        }
+    }
+  else
+    {
+      /* note that the source is not being set */
+      heal->set_source = FALSE;
+
+      if (display == heal_tool->src_display)
+        {
+          paint_tool->core->use_saved_proj = TRUE;
+        }
+    }
+
+  /* chain up to call the parents functions */
+  GIMP_TOOL_CLASS (gimp_heal_tool_parent_class)->button_press (tool, coords, time, state,
+                                                display);
+
+  /* set the tool display's source position to match the current clone 
+   * implementation source position */
+  heal_tool->src_x = heal->src_x;
+  heal_tool->src_y = heal->src_y;
+
+  /* resume drawing */
+  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
+}
+
+static void
+gimp_heal_tool_motion (GimpTool        *tool,
+                       GimpCoords      *coords,
+                       guint32          time,
+                       GdkModifierType  state,
+                       GimpDisplay     *display)
+{
+  GimpHealTool    *heal_tool    = GIMP_HEAL_TOOL (tool);
+  GimpPaintTool   *paint_tool   = GIMP_PAINT_TOOL (tool);
+  GimpHeal        *heal         = GIMP_HEAL (paint_tool->core);
+
+  /* pause drawing */
+  gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
+
+  /* check if CTRL is pressed */
+  if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
+    /* if yes the source has been set */
+    heal->set_source = TRUE;
+  else
+    /* if no the source has not been set */
+    heal->set_source = FALSE;
+
+  /* chain up to the parent classes motion function */
+  GIMP_TOOL_CLASS (gimp_heal_tool_parent_class)->motion (tool, coords, time, state, display);
+
+  /* set the tool display's source to be the same as the clone implementation
+   * source */
+  heal_tool->src_x = heal->src_x;
+  heal_tool->src_y = heal->src_y;
+
+  /* resume drawing */
+  gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
+}
+
+static void
+gimp_heal_tool_cursor_update (GimpTool        *tool,
+                              GimpCoords      *coords,
+                              GdkModifierType  state,
+                              GimpDisplay     *display)
+{
+  GimpCursorType        cursor   = GIMP_CURSOR_MOUSE;
+  GimpCursorModifier    modifier = GIMP_CURSOR_MODIFIER_NONE;
+
+  /* if the cursor is in an active area */
+  if (gimp_image_coords_in_active_pickable (display->image, coords,
+                                            FALSE, TRUE))
+    {
+      /* set the cursor to the normal cursor */
+      cursor = GIMP_CURSOR_MOUSE;
+    }
+
+  if ((state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
+    {
+      cursor = GIMP_CURSOR_CROSSHAIR_SMALL;
+    }
+  else if (! GIMP_HEAL (GIMP_PAINT_TOOL (tool)->core)->src_drawable)
+    {
+      modifier = GIMP_CURSOR_MODIFIER_BAD;
+    }
+
+  /* set the cursor and the modifier cursor */
+  gimp_tool_control_set_cursor          (tool->control, cursor);
+  gimp_tool_control_set_cursor_modifier (tool->control, modifier);
+
+  /* chain up to the parent class */
+  GIMP_TOOL_CLASS (gimp_heal_tool_parent_class)->cursor_update (tool, coords, state, display);
+}
+
+static void
+gimp_heal_tool_oper_update (GimpTool        *tool,
+                            GimpCoords      *coords,
+                            GdkModifierType  state,
+                            gboolean         proximity,
+                            GimpDisplay     *display)
+{
+  GimpHealTool    *heal_tool = GIMP_HEAL_TOOL (tool);
+
+  /* chain up to the parent class */
+  GIMP_TOOL_CLASS (gimp_heal_tool_parent_class)->oper_update (tool, coords, state, proximity,
+                                               display);
+
+  /* FIXME: what does proximity mean? */
+  if (proximity)
+    {
+      GimpHeal *heal = GIMP_HEAL (GIMP_PAINT_TOOL (tool)->core);
+
+      if (heal->src_drawable == NULL)
+        {
+          /* if we haven't set the source drawable yet, make a notice to do so */
+          gimp_tool_replace_status (tool, display,
+                                    _("Ctrl-Click to set a heal source."));
+        }
+      else
+        {
+          /* pause drawing */
+          gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
+
+          /* set the tool source to match the implementation source */
+          heal_tool->src_x = heal->src_x;
+          heal_tool->src_y = heal->src_y;
+
+          if (! heal->first_stroke)
+            {
+              heal_tool->src_x = coords->x + heal->offset_x;
+              heal->src_y = coords->y + heal->offset_y;
+            }
+
+          /* resume drawing */
+          gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
+        }
+    }
+}
+
+static void
+gimp_heal_tool_draw (GimpDrawTool *draw_tool)
+{
+  GimpTool        *tool      = GIMP_TOOL (draw_tool);
+  GimpHealTool    *heal_tool = GIMP_HEAL_TOOL (draw_tool);
+  GimpHeal        *heal      = GIMP_HEAL (GIMP_PAINT_TOOL (tool)->core);
+
+  /* If we have a source drawable and display we can do the drawing */
+  if (heal->src_drawable && heal_tool->src_display)
+    {
+      /* make a temporary display and keep track of offsets */
+      GimpDisplay *tmp_display;
+      gint         off_x;
+      gint         off_y;
+
+      /* gimp_item_offsets reveals the X and Y offsets of the first parameter.
+       * this gets the location of the drawable. */
+      gimp_item_offsets (GIMP_ITEM (heal->src_drawable), &off_x, &off_y);
+
+      /* store the display for later */
+      tmp_display = draw_tool->display;
+
+      /* set the display */
+      draw_tool->display = heal_tool->src_display;
+
+      /* convenience function to simplify drawing */
+      gimp_draw_tool_draw_handle (draw_tool,
+                                  GIMP_HANDLE_CROSS,
+                                  heal_tool->src_x + off_x,
+                                  heal_tool->src_y + off_y,
+                                  TARGET_WIDTH, TARGET_HEIGHT,
+                                  GTK_ANCHOR_CENTER,
+                                  FALSE);
+
+      /* FIXME: why do we reset the display after calling the
+       * gimp_draw_tool_draw_handle function? */
+      draw_tool->display = tmp_display;
+    }
+
+  /* chain up to the parent draw function */
+  GIMP_DRAW_TOOL_CLASS (gimp_heal_tool_parent_class)->draw (draw_tool);
+}
+
+/* FIXME:  Tailor this to the healing brush */
+static GtkWidget *
+gimp_heal_options_gui (GimpToolOptions *tool_options)
+{
+  GObject   *config;
+  GtkWidget *vbox;
+  GtkWidget *frame;
+  GtkWidget *button;
+  GtkWidget *hbox;
+  GtkWidget *table;
+  GtkWidget *combo;
+
+  config = G_OBJECT (tool_options);
+
+  vbox = gimp_paint_options_gui (tool_options);
+
+  return vbox;
+}
Index: gimp/app/tools/gimphealtool.h
===================================================================
RCS file: gimp/app/tools/gimphealtool.h
diff -N gimp/app/tools/gimphealtool.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/app/tools/gimphealtool.h	4 Aug 2006 15:50:18 -0000
@@ -0,0 +1,54 @@
+/* The GIMP -- an image manipulation program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GIMP_HEAL_TOOL_H__
+#define __GIMP_HEAL_TOOL_H__
+
+#include "gimppainttool.h"
+
+#define GIMP_TYPE_HEAL_TOOL            (gimp_heal_tool_get_type ())
+#define GIMP_HEAL_TOOL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_HEAL_TOOL, GimpHealTool))
+#define GIMP_HEAL_TOOL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_HEAL_TOOL, GimpHealToolClass))
+#define GIMP_IS_HEAL_TOOL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_HEAL_TOOL))
+#define GIMP_IS_HEAL_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_HEAL_TOOL))
+#define GIMP_HEAL_TOOL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_HEAL_TOOL, GimpHealToolClass))
+
+typedef struct _GimpHealTool      GimpHealTool;
+typedef struct _GimpHealToolClass GimpHealToolClass;
+
+struct _GimpHealTool
+{
+  GimpPaintTool  parent_instance;
+
+  GimpDisplay   *src_display;   /* Detail about the source location to paint from */
+  gint           src_x;
+  gint           src_y;
+};
+
+struct _GimpHealToolClass
+{
+  GimpPaintToolClass parent_class;
+};
+
+
+void    gimp_heal_tool_register (GimpToolRegisterCallback  callback,
+                                    gpointer                  data);
+
+GType   gimp_heal_tool_get_type (void) G_GNUC_CONST;
+
+#endif  /*  __GIMP_HEAL_TOOL_H__  */
Index: gimp/app/tools/gimppaintoptions-gui.c
===================================================================
RCS file: /cvs/gnome/gimp/app/tools/gimppaintoptions-gui.c,v
retrieving revision 1.113
diff -u -p -r1.113 gimppaintoptions-gui.c
--- gimp/app/tools/gimppaintoptions-gui.c	20 Feb 2006 17:25:53 -0000	1.113
+++ gimp/app/tools/gimppaintoptions-gui.c	4 Aug 2006 15:50:19 -0000
@@ -44,6 +44,7 @@
 #include "gimpdodgeburntool.h"
 #include "gimpdodgeburntool.h"
 #include "gimperasertool.h"
+#include "gimphealtool.h"
 #include "gimpinktool.h"
 #include "gimppaintbrushtool.h"
 #include "gimppaintoptions-gui.h"
@@ -184,6 +185,7 @@ gimp_paint_options_gui (GimpToolOptions 
   /* the "hard edge" toggle */
   if (tool_type == GIMP_TYPE_ERASER_TOOL     ||
       tool_type == GIMP_TYPE_CLONE_TOOL      ||
+      tool_type == GIMP_TYPE_HEAL_TOOL       ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL   ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
       tool_type == GIMP_TYPE_SMUDGE_TOOL)
@@ -220,6 +222,7 @@ pressure_options_gui (GimpPressureOption
 
   if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL) ||
       tool_type == GIMP_TYPE_CLONE_TOOL                  ||
+      tool_type == GIMP_TYPE_HEAL_TOOL                   ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL               ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL             ||
       tool_type == GIMP_TYPE_ERASER_TOOL                 ||
@@ -244,6 +247,7 @@ pressure_options_gui (GimpPressureOption
   /*  the opacity toggle  */
   if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL) ||
       tool_type == GIMP_TYPE_CLONE_TOOL                  ||
+      tool_type == GIMP_TYPE_HEAL_TOOL                   ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL             ||
       tool_type == GIMP_TYPE_ERASER_TOOL)
     {
@@ -256,6 +260,7 @@ pressure_options_gui (GimpPressureOption
   /*  the pressure toggle  */
   if (tool_type == GIMP_TYPE_AIRBRUSH_TOOL   ||
       tool_type == GIMP_TYPE_CLONE_TOOL      ||
+      tool_type == GIMP_TYPE_HEAL_TOOL       ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL   ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
       tool_type == GIMP_TYPE_PAINTBRUSH_TOOL ||
@@ -280,6 +285,7 @@ pressure_options_gui (GimpPressureOption
 
   /*  the size toggle  */
   if (tool_type == GIMP_TYPE_CLONE_TOOL      ||
+      tool_type == GIMP_TYPE_HEAL_TOOL       ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL   ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL ||
       tool_type == GIMP_TYPE_ERASER_TOOL     ||
@@ -323,6 +329,7 @@ fade_options_gui (GimpFadeOptions  *fade
 
   if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL) ||
       tool_type == GIMP_TYPE_CLONE_TOOL                  ||
+      tool_type == GIMP_TYPE_HEAL_TOOL                   ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL               ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL             ||
       tool_type == GIMP_TYPE_ERASER_TOOL                 ||
@@ -382,6 +389,7 @@ jitter_options_gui (GimpJitterOptions  *
 
   if (g_type_is_a (tool_type, GIMP_TYPE_PAINTBRUSH_TOOL) ||
       tool_type == GIMP_TYPE_CLONE_TOOL                  ||
+      tool_type == GIMP_TYPE_HEAL_TOOL                   ||
       tool_type == GIMP_TYPE_CONVOLVE_TOOL               ||
       tool_type == GIMP_TYPE_DODGE_BURN_TOOL             ||
       tool_type == GIMP_TYPE_ERASER_TOOL                 ||
Index: gimp/app/widgets/gimphelp-ids.h
===================================================================
RCS file: /cvs/gnome/gimp/app/widgets/gimphelp-ids.h,v
retrieving revision 1.77
diff -u -p -r1.77 gimphelp-ids.h
--- gimp/app/widgets/gimphelp-ids.h	13 Jun 2006 02:03:44 -0000	1.77
+++ gimp/app/widgets/gimphelp-ids.h	4 Aug 2006 15:50:19 -0000
@@ -253,6 +253,7 @@
 #define GIMP_HELP_TOOL_FREE_SELECT                "gimp-tool-free-select"
 #define GIMP_HELP_TOOL_FOREGROUND_SELECT          "gimp-tool-foreground-select"
 #define GIMP_HELP_TOOL_FUZZY_SELECT               "gimp-tool-fuzzy-select"
+#define GIMP_HELP_TOOL_HEAL                       "gimp-tool-heal"
 #define GIMP_HELP_TOOL_HUE_SATURATION             "gimp-tool-hue-saturation"
 #define GIMP_HELP_TOOL_INK                        "gimp-tool-ink"
 #define GIMP_HELP_TOOL_ISCISSORS                  "gimp-tool-iscissors"
Index: gimp/app/widgets/widgets-enums.h
===================================================================
RCS file: /cvs/gnome/gimp/app/widgets/widgets-enums.h,v
retrieving revision 1.47
diff -u -p -r1.47 widgets-enums.h
--- gimp/app/widgets/widgets-enums.h	2 Jun 2006 15:23:47 -0000	1.47
+++ gimp/app/widgets/widgets-enums.h	4 Aug 2006 15:50:20 -0000
@@ -251,6 +251,7 @@ typedef enum  /*< skip >*/
   GIMP_TOOL_CURSOR_AIRBRUSH,
   GIMP_TOOL_CURSOR_INK,
   GIMP_TOOL_CURSOR_CLONE,
+  GIMP_TOOL_CURSOR_HEAL,
   GIMP_TOOL_CURSOR_ERASER,
   GIMP_TOOL_CURSOR_SMUDGE,
   GIMP_TOOL_CURSOR_BLUR,
Index: gimp/cursors/Makefile.am
===================================================================
RCS file: /cvs/gnome/gimp/cursors/Makefile.am,v
retrieving revision 1.11
diff -u -p -r1.11 Makefile.am
--- gimp/cursors/Makefile.am	2 Jun 2006 15:11:17 -0000	1.11
+++ gimp/cursors/Makefile.am	4 Aug 2006 15:50:20 -0000
@@ -46,6 +46,7 @@ CURSOR_IMAGES = \
 	tool-free-select.png		\
 	tool-fuzzy-select.png		\
 	tool-hand.png			\
+	tool-heal.png			\
 	tool-ink.png			\
 	tool-iscissors.png		\
 	tool-measure.png		\
@@ -193,7 +194,8 @@ EXTRA_DIST = \
 	xbm/tool-measure.xbm			\
 	xbm/tool-measure-mask.xbm		\
 	xbm/tool-hand.xbm			\
-	xbm/tool-hand-mask.xbm
+	xbm/tool-hand-mask.xbm		\
+	xbm/tool-heal.xbm
 
 noinst_DATA = gimp-tool-cursors.h
 
Index: gimp/cursors/makefile.msc
===================================================================
RCS file: /cvs/gnome/gimp/cursors/makefile.msc,v
retrieving revision 1.2
diff -u -p -r1.2 makefile.msc
--- gimp/cursors/makefile.msc	25 Sep 2005 19:30:51 -0000	1.2
+++ gimp/cursors/makefile.msc	4 Aug 2006 15:50:20 -0000
@@ -35,6 +35,7 @@ CURSOR_LIST = \
 	tool_free_select		tool-free-select.png \
 	tool_fuzzy_select		tool-fuzzy-select.png \
 	tool_hand		tool-hand.png \
+  tool_heal   tool-heal.png \
 	tool_ink		tool-ink.png \
 	tool_iscissors		tool-iscissors.png \
 	tool_measure		tool-measure.png \
Index: gimp/cursors/tool-heal.png
===================================================================
RCS file: gimp/cursors/tool-heal.png
diff -N gimp/cursors/tool-heal.png
Binary files /dev/null and tool-heal.png differ
Index: gimp/cursors/xbm/tool-heal-mask.xbm
===================================================================
RCS file: gimp/cursors/xbm/tool-heal-mask.xbm
diff -N gimp/cursors/xbm/tool-heal-mask.xbm
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/cursors/xbm/tool-heal-mask.xbm	4 Aug 2006 15:50:21 -0000
@@ -0,0 +1,14 @@
+#define tool_clone_mask_width 32
+#define tool_clone_mask_height 32
+static unsigned char tool_clone_mask_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xf0, 0x07,
+   0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf8, 0x0f,
+   0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03,
+   0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0xff, 0x7f, 0x00, 0x80, 0xff, 0xff,
+   0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff,
+   0x00, 0x00, 0xff, 0x7f, 0x00, 0x00, 0xfe, 0x3f };
Index: gimp/cursors/xbm/tool-heal.xbm
===================================================================
RCS file: gimp/cursors/xbm/tool-heal.xbm
diff -N gimp/cursors/xbm/tool-heal.xbm
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gimp/cursors/xbm/tool-heal.xbm	4 Aug 2006 15:50:21 -0000
@@ -0,0 +1,14 @@
+#define tool_heal_width 32
+#define tool_heal_height 32
+static unsigned char tool_heal_bits[] = {
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00,
+   0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x40, 0x0a, 0x00,
+   0x00, 0x20, 0x18, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x08, 0x60, 0x00,
+   0x00, 0x02, 0xc0, 0x01, 0x00, 0x03, 0xc0, 0x01, 0x00, 0x03, 0xc0, 0x01,
+   0x00, 0x00, 0xc0, 0x03, 0x00, 0x08, 0x60, 0x02, 0x00, 0x10, 0xb0, 0x02,
+   0x00, 0x20, 0x10, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x86, 0x03, 0x00,
+   0x00, 0x80, 0x03, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
Index: gimp/devel-docs/libgimp/tmpl/gimpfontselectbutton.sgml
===================================================================
RCS file: /cvs/gnome/gimp/devel-docs/libgimp/tmpl/gimpfontselectbutton.sgml,v
retrieving revision 1.4
diff -u -p -r1.4 gimpfontselectbutton.sgml
--- gimp/devel-docs/libgimp/tmpl/gimpfontselectbutton.sgml	5 Jul 2006 10:11:24 -0000	1.4
+++ gimp/devel-docs/libgimp/tmpl/gimpfontselectbutton.sgml	4 Aug 2006 15:50:21 -0000
@@ -32,6 +32,25 @@ GimpFontSelectButton
 @arg1: 
 @arg2: 
 
+<!-- ##### SIGNAL GimpFontSelectButton::font-set ##### -->
+<para>
+
+</para>
+
+@: 
+@: 
+@: 
+
+<!-- ##### ARG GimpFontSelectButton:font-name ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GimpFontSelectButton:title ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GimpFontSelectButton:font-name ##### -->
 <para>
 
Index: gimp/devel-docs/libgimpwidgets/tmpl/gimpstock.sgml
===================================================================
RCS file: /cvs/gnome/gimp/devel-docs/libgimpwidgets/tmpl/gimpstock.sgml,v
retrieving revision 1.59
diff -u -p -r1.59 gimpstock.sgml
--- gimp/devel-docs/libgimpwidgets/tmpl/gimpstock.sgml	28 Jun 2006 10:35:19 -0000	1.59
+++ gimp/devel-docs/libgimpwidgets/tmpl/gimpstock.sgml	4 Aug 2006 15:50:22 -0000
@@ -490,6 +490,7 @@ RTL variant
 </para>
 
 
+
 <!-- ##### MACRO GIMP_STOCK_CURSOR ##### -->
 <para xml:base="../gimpstock.xml">
 <inlinegraphic fileref="stock-cursor-24.png" format="png"></inlinegraphic>
@@ -1448,3 +1449,6 @@ RTL variant
 <para>
 
 </para>
+
+
+
Index: gimp/libgimpwidgets/gimpstock.c
===================================================================
RCS file: /cvs/gnome/gimp/libgimpwidgets/gimpstock.c,v
retrieving revision 1.87
diff -u -p -r1.87 gimpstock.c
--- gimp/libgimpwidgets/gimpstock.c	16 Jun 2006 15:06:57 -0000	1.87
+++ gimp/libgimpwidgets/gimpstock.c	4 Aug 2006 15:50:24 -0000
@@ -287,6 +287,7 @@ static const GtkStockItem gimp_stock_ite
   { GIMP_STOCK_TOOL_FOREGROUND_SELECT,   NULL,        0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_TOOL_FUZZY_SELECT,        NULL,        0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_TOOL_HUE_SATURATION,      NULL,        0, 0, LIBGIMP_DOMAIN },
+  { GIMP_STOCK_TOOL_HEAL,                NULL,        0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_TOOL_INK,                 NULL,        0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_TOOL_ISCISSORS,           NULL,        0, 0, LIBGIMP_DOMAIN },
   { GIMP_STOCK_TOOL_LEVELS,              NULL,        0, 0, LIBGIMP_DOMAIN },
@@ -422,6 +423,7 @@ gimp_stock_button_pixbufs[] =
   { GIMP_STOCK_TOOL_FREE_SELECT,         stock_tool_free_select_22         },
   { GIMP_STOCK_TOOL_FOREGROUND_SELECT,   stock_tool_foreground_select_22   },
   { GIMP_STOCK_TOOL_FUZZY_SELECT,        stock_tool_fuzzy_select_22        },
+  { GIMP_STOCK_TOOL_HEAL,                stock_tool_heal_22                },
   { GIMP_STOCK_TOOL_HUE_SATURATION,      stock_tool_hue_saturation_22      },
   { GIMP_STOCK_TOOL_INK,                 stock_tool_ink_22                 },
   { GIMP_STOCK_TOOL_ISCISSORS,           stock_tool_iscissors_22           },
@@ -568,6 +570,7 @@ gimp_stock_menu_pixbufs[] =
   { GIMP_STOCK_TOOL_FREE_SELECT,         stock_tool_free_select_16         },
   { GIMP_STOCK_TOOL_FOREGROUND_SELECT,   stock_tool_foreground_select_16   },
   { GIMP_STOCK_TOOL_FUZZY_SELECT,        stock_tool_fuzzy_select_16        },
+  { GIMP_STOCK_TOOL_HEAL,                stock_tool_heal_16                },
   { GIMP_STOCK_TOOL_HUE_SATURATION,      stock_tool_hue_saturation_16      },
   { GIMP_STOCK_TOOL_INK,                 stock_tool_ink_16                 },
   { GIMP_STOCK_TOOL_ISCISSORS,           stock_tool_iscissors_16           },
Index: gimp/libgimpwidgets/gimpstock.h
===================================================================
RCS file: /cvs/gnome/gimp/libgimpwidgets/gimpstock.h,v
retrieving revision 1.68
diff -u -p -r1.68 gimpstock.h
--- gimp/libgimpwidgets/gimpstock.h	16 Jun 2006 15:06:57 -0000	1.68
+++ gimp/libgimpwidgets/gimpstock.h	4 Aug 2006 15:50:24 -0000
@@ -118,6 +118,7 @@ G_BEGIN_DECLS
 #define GIMP_STOCK_TOOL_FREE_SELECT         "gimp-tool-free-select"
 #define GIMP_STOCK_TOOL_FOREGROUND_SELECT   "gimp-tool-foreground-select"
 #define GIMP_STOCK_TOOL_FUZZY_SELECT        "gimp-tool-fuzzy-select"
+#define GIMP_STOCK_TOOL_HEAL                "gimp-tool-heal"
 #define GIMP_STOCK_TOOL_HUE_SATURATION      "gimp-tool-hue-saturation"
 #define GIMP_STOCK_TOOL_INK                 "gimp-tool-ink"
 #define GIMP_STOCK_TOOL_ISCISSORS           "gimp-tool-iscissors"
Index: gimp/themes/Default/images/makefile.msc
===================================================================
RCS file: /cvs/gnome/gimp/themes/Default/images/makefile.msc,v
retrieving revision 1.14
diff -u -p -r1.14 makefile.msc
--- gimp/themes/Default/images/makefile.msc	25 Sep 2005 19:30:55 -0000	1.14
+++ gimp/themes/Default/images/makefile.msc	4 Aug 2006 15:50:26 -0000
@@ -249,6 +249,8 @@ STOCK_TOOL_VARIABLES = \
 	stock_tool_free_select_22		tools/stock-tool-free-select-22.png	\
 	stock_tool_fuzzy_select_16		tools/stock-tool-fuzzy-select-16.png	\
 	stock_tool_fuzzy_select_22		tools/stock-tool-fuzzy-select-22.png	\
+  stock_tool_heal_16		tools/stock-tool-heal-16.png	\
+	stock_tool_heal_22		tools/stock-tool-heal-22.png	\
 	stock_tool_hue_saturation_16		tools/stock-tool-hue-saturation-16.png	\
 	stock_tool_hue_saturation_22		tools/stock-tool-hue-saturation-22.png	\
 	stock_tool_ink_16		tools/stock-tool-ink-16.png	\
Index: gimp/themes/Default/images/tools/stock-tool-heal-16.png
===================================================================
RCS file: gimp/themes/Default/images/tools/stock-tool-heal-16.png
diff -N gimp/themes/Default/images/tools/stock-tool-heal-16.png
Binary files /dev/null and stock-tool-heal-16.png differ
Index: gimp/themes/Default/images/tools/stock-tool-heal-22.png
===================================================================
RCS file: gimp/themes/Default/images/tools/stock-tool-heal-22.png
diff -N gimp/themes/Default/images/tools/stock-tool-heal-22.png
Binary files /dev/null and stock-tool-heal-22.png differ
