Index: app/core/gimpcoords-interpolate.c
===================================================================
--- app/core/gimpcoords-interpolate.c	(revision 27571)
+++ app/core/gimpcoords-interpolate.c	(working copy)
@@ -40,6 +40,11 @@
                                                          GArray          **ret_coords,
                                                          GArray          **ret_params,
                                                          gint              depth);
+static gdouble  gimp_coords_get_catmull_spline_point    (gdouble           t,
+                                                         gdouble           p0,
+                                                         gdouble           p1,
+                                                         gdouble           p2,
+                                                         gdouble           p3);
 
 /* Functions for bezier subdivision */
 
@@ -208,3 +213,116 @@
   return (gimp_coords_manhattan_dist (&bezier_pt2, &pt1) < precision &&
           gimp_coords_manhattan_dist (&bezier_pt3, &pt2) < precision);
 }
+
+
+/* Functions for camull-rom interpolation */
+
+void
+gimp_coords_interpolate_catmull (const GimpCoords catmul_pt1,
+                                 const GimpCoords catmul_pt2,
+                                 const GimpCoords catmul_pt3,
+                                 const GimpCoords catmul_pt4,
+                                 gdouble          precision,
+                                 GArray           **ret_coords,
+                                 GArray           **ret_params)
+{
+  gdouble        delta_x, delta_y;
+  gdouble        distance;
+  gint           num_points;
+  gint           n;
+
+  GimpCoords     past_coords;
+  GimpCoords     start_coords;
+  GimpCoords     end_coords;
+  GimpCoords     future_coords;
+
+
+  delta_x        = catmul_pt3.x - catmul_pt2.x;
+  delta_y        = catmul_pt3.y - catmul_pt2.y;
+
+
+  /* Catmull-Rom interpolation requires 4 points. Two endpoints plus one more at
+	 each end. */
+
+  past_coords   = catmul_pt1;
+  start_coords  = catmul_pt2;
+  end_coords    = catmul_pt3;
+  future_coords = catmul_pt4;
+
+
+  distance  = sqrt (SQR (delta_x) + SQR (delta_y));
+
+  num_points = distance / precision;
+
+
+
+
+  for (n = 1; n <=num_points; n++)
+    {
+      GimpCoords     res_coords;
+	    gdouble p = (gdouble) n / num_points;
+
+	    res_coords.x        = gimp_coords_get_catmull_spline_point (p,
+                                                                  past_coords.x,
+                                                                  start_coords.x,
+                                                                  end_coords.x,
+                                                                  future_coords.x);
+/*	printf("p:%f, past:%f, start:%f, end:%f, next:%f , curr:%f\n", p,
+		                                                           past_coords.x,
+		                                                           start_coords.x,
+		                                                           end_coords.x,
+		                                                           future_coords.x,
+		                                                           paint_core->cur_coords.x);
+*/
+	    res_coords.y        = gimp_coords_get_catmull_spline_point (p,
+                                                                  past_coords.y,
+				 					                                                start_coords.y,
+									                                                end_coords.y,
+									                                                future_coords.y);
+
+	    res_coords.pressure = gimp_coords_get_catmull_spline_point (p,
+                                                                  past_coords.pressure,
+                                                                  start_coords.pressure,
+									                                                end_coords.pressure,
+									                                                future_coords.pressure);
+	    res_coords.xtilt    = gimp_coords_get_catmull_spline_point (p,
+								                                 	                past_coords.xtilt,
+                                                                  start_coords.xtilt,
+									                                                end_coords.xtilt,
+									                                                future_coords.xtilt);
+	    res_coords.ytilt    = gimp_coords_get_catmull_spline_point (p,
+                                                                  past_coords.ytilt,
+                                                                  start_coords.ytilt,
+									                                                end_coords.ytilt,
+									                                                future_coords.ytilt);
+	    res_coords.wheel    = gimp_coords_get_catmull_spline_point (p,
+								                            	                    past_coords.wheel,
+				 					                                                start_coords.wheel,
+									                                                end_coords.wheel,
+									                                                future_coords.wheel);
+	    res_coords.velocity = CLAMP (gimp_coords_get_catmull_spline_point (p,
+                                                                         past_coords.velocity,
+                                                                         start_coords.velocity,
+                                                                         end_coords.velocity,
+                                                                         future_coords.velocity), 0.0, 1.0);
+
+      g_array_append_val (*ret_coords, res_coords);
+      if (ret_params)
+        {
+          g_array_append_val (*ret_params, p);
+        }
+
+    }
+}
+
+static gdouble
+gimp_coords_get_catmull_spline_point (gdouble  t,
+                                      gdouble  p0,
+                                      gdouble  p1,
+                                      gdouble  p2,
+                                      gdouble  p3)
+{
+
+   return (((-t+2.0)*t-1.0)*t/2.0) * p0 + ((((3.0*t-5.0)*t)*t+2-0)/2.0) * p1
+		+ (((-3.0*t+4.0)*t+1.0)*t/2.0) * p2 + (((t-1)*t*t)/2.0) * p3;
+}
Index: app/core/gimpcoords-interpolate.h
===================================================================
--- app/core/gimpcoords-interpolate.h	(revision 27571)
+++ app/core/gimpcoords-interpolate.h	(working copy)
@@ -21,18 +21,26 @@
 #ifndef __GIMP_COORDS_INTERPOLATE_H__
 #define __GIMP_COORDS_INTERPOLATE_H__
 
-void      gimp_coords_interpolate_bezier (const GimpCoords bezier_pt1,
-                                          const GimpCoords bezier_pt2,
-                                          const GimpCoords bezier_pt3,
-                                          const GimpCoords bezier_pt4,
-                                          gdouble          precision,
-                                          GArray           **ret_coords,
-                                          GArray           **ret_params);
+void      gimp_coords_interpolate_bezier  (const GimpCoords bezier_pt1,
+                                           const GimpCoords bezier_pt2,
+                                           const GimpCoords bezier_pt3,
+                                           const GimpCoords bezier_pt4,
+                                           gdouble          precision,
+                                           GArray           **ret_coords,
+                                           GArray           **ret_params);
 
-gboolean  gimp_coords_bezier_is_straight (const GimpCoords bezier_pt1,
-                                          const GimpCoords bezier_pt2,
-                                          const GimpCoords bezier_pt3,
-                                          const GimpCoords bezier_pt4,
-                                          gdouble           precision);
+gboolean  gimp_coords_bezier_is_straight  (const GimpCoords bezier_pt1,
+                                           const GimpCoords bezier_pt2,
+                                           const GimpCoords bezier_pt3,
+                                           const GimpCoords bezier_pt4,
+                                           gdouble          precision);
 
+void      gimp_coords_interpolate_catmull (const GimpCoords catmul_pt1,
+                                           const GimpCoords catmul_pt2,
+                                           const GimpCoords catmul_pt3,
+                                           const GimpCoords catmul_pt4,
+                                           gdouble          precision,
+                                           GArray           **ret_coords,
+                                           GArray           **ret_params);
+
 #endif /* __GIMP_COORDS_INTERPOLATE_H__ */
Index: app/display/gimpdisplayshell.c
===================================================================
--- app/display/gimpdisplayshell.c	(revision 27571)
+++ app/display/gimpdisplayshell.c	(working copy)
@@ -82,7 +82,6 @@
 
 #include "gimp-intl.h"
 
-
 enum
 {
   PROP_0,
@@ -355,6 +354,17 @@
   shell->last_motion_distance   = 0.0;
   shell->last_motion_delta_time = 0.0;
 
+  shell->event_history          = g_array_sized_new (FALSE, FALSE,
+                                                     sizeof (GimpCoords), 4);
+  shell->event_queue            = g_array_new       (FALSE, FALSE,
+                                                     sizeof (GimpCoords));
+  shell->event_delay            = FALSE;
+
+  shell->event_delay_timeout    = 0;
+
+  shell->last_active_state      = 0;
+
+
   gtk_window_set_role (GTK_WINDOW (shell), "gimp-image-window");
   gtk_window_set_resizable (GTK_WINDOW (shell), TRUE);
 
@@ -497,6 +507,17 @@
       shell->mask = NULL;
     }
 
+  if (shell->event_history)
+    {
+      g_array_free (shell->event_history, TRUE);
+      shell->event_history = NULL;
+    }
+  if (shell->event_queue)
+    {
+      g_array_free (shell->event_queue, TRUE);
+      shell->event_queue = NULL;
+    }
+
   if (shell->title_idle_id)
     {
       g_source_remove (shell->title_idle_id);
Index: app/display/gimpdisplayshell.h
===================================================================
--- app/display/gimpdisplayshell.h	(revision 27571)
+++ app/display/gimpdisplayshell.h	(working copy)
@@ -196,6 +196,13 @@
   gdouble            last_motion_delta_y;
   gdouble            last_motion_distance;
 
+  GArray            *event_history;
+  GArray            *event_queue;
+  gboolean           event_delay;  /*  true if theres an unsent event in the history buffer, false otherwise */
+
+  gint               event_delay_timeout;
+  GdkModifierType    last_active_state;
+
 };
 
 struct _GimpDisplayShellClass
Index: app/display/gimpdisplayshell-callbacks.c
===================================================================
--- app/display/gimpdisplayshell-callbacks.c	(revision 27571)
+++ app/display/gimpdisplayshell-callbacks.c	(working copy)
@@ -80,28 +80,31 @@
 
 /*  local function prototypes  */
 
-static void       gimp_display_shell_vscrollbar_update       (GtkAdjustment    *adjustment,
-                                                              GimpDisplayShell *shell);
-static void       gimp_display_shell_hscrollbar_update       (GtkAdjustment    *adjustment,
-                                                              GimpDisplayShell *shell);
-static gboolean   gimp_display_shell_vscrollbar_update_range (GtkRange         *range,
-                                                              GtkScrollType     scroll,
-                                                              gdouble           value,
-                                                              GimpDisplayShell *shell);
+static void       gimp_display_shell_vscrollbar_update        (GtkAdjustment    *adjustment,
+                                                               GimpDisplayShell *shell);
+static void       gimp_display_shell_hscrollbar_update        (GtkAdjustment    *adjustment,
+                                                               GimpDisplayShell *shell);
+static gboolean   gimp_display_shell_vscrollbar_update_range  (GtkRange         *range,
+                                                               GtkScrollType     scroll,
+                                                               gdouble           value,
+                                                               GimpDisplayShell *shell);
 
-static gboolean   gimp_display_shell_hscrollbar_update_range (GtkRange         *range,
-                                                              GtkScrollType     scroll,
-                                                              gdouble           value,
-                                                              GimpDisplayShell *shell);
+static gboolean   gimp_display_shell_hscrollbar_update_range  (GtkRange         *range,
+                                                               GtkScrollType     scroll,
+                                                               gdouble           value,
+                                                               GimpDisplayShell *shell);
 static GdkModifierType
-                  gimp_display_shell_key_to_state            (gint              key);
+                  gimp_display_shell_key_to_state             (gint              key);
 
-static GdkEvent * gimp_display_shell_compress_motion         (GimpDisplayShell *shell);
+static GdkEvent * gimp_display_shell_compress_motion          (GimpDisplayShell *shell);
 
-static void       gimp_display_shell_canvas_expose_image     (GimpDisplayShell *shell,
-                                                              GdkEventExpose   *eevent);
-static void       gimp_display_shell_canvas_expose_drop_zone (GimpDisplayShell *shell,
-                                                              GdkEventExpose   *eevent);
+static void       gimp_display_shell_canvas_expose_image      (GimpDisplayShell *shell,
+                                                               GdkEventExpose   *eevent);
+static void       gimp_display_shell_canvas_expose_drop_zone  (GimpDisplayShell *shell,
+                                                               GdkEventExpose   *eevent);
+static void       gimp_display_shell_process_tool_event_queue (GimpDisplayShell *shell,
+                                                               GdkModifierType   state,
+                                                               guint32           time);
 
 
 /*  public functions  */
@@ -1002,6 +1005,10 @@
               {
                 if (gimp_tool_control_is_active (active_tool->control))
                   {
+
+                    if (shell->event_queue->len > 0)
+                      gimp_display_shell_flush_event_queue (shell);
+
                     tool_manager_button_release_active (gimp,
                                                         &image_coords,
                                                         time, state,
@@ -1255,6 +1262,7 @@
 
                     for (i = 0; i < n_history_events; i++)
                       {
+
                         gimp_display_shell_get_time_coords (shell,
                                                             mevent->device,
                                                             history_events[i],
@@ -1286,11 +1294,7 @@
                                                            active_tool->max_coord_smooth,
                                                            history_events[i]->time))
                           {
-                            tool_manager_motion_active (gimp,
-                                                        &image_coords,
-                                                        history_events[i]->time,
-                                                        state,
-                                                        display);
+                            gimp_display_shell_process_tool_event_queue (shell, state, history_events[i]->time);
                           }
 
                          shell->last_read_motion_time = history_events[i]->time;
@@ -1300,6 +1304,7 @@
                   }
                 else
                   {
+
                     /* Early removal of useless events saves CPU time.
                      */
                     if (gimp_display_shell_eval_event (shell,
@@ -1307,11 +1312,7 @@
                                                        active_tool->max_coord_smooth,
                                                        time))
                       {
-                        tool_manager_motion_active (gimp,
-                                                    &image_coords,
-                                                    time,
-                                                    state,
-                                                    display);
+                        gimp_display_shell_process_tool_event_queue (shell, state, time);
                       }
 
                     shell->last_read_motion_time = time;
@@ -1325,17 +1326,22 @@
             /* Early removal of useless events saves CPU time.
              * Smoothing is 0.0 here for coasting.
              */
+
             if (gimp_display_shell_eval_event (shell,
                                                &image_coords,
                                                0.0,
                                                time))
               {
-                tool_manager_oper_update_active (gimp,
-                                                 &image_coords, state,
-                                                 shell->proximity,
-                                                 display);
+                  /* then update the tool. */
+                  GimpCoords *buf_coords = &g_array_index (shell->event_queue, GimpCoords, 0);
+                  tool_manager_oper_update_active (gimp,
+                                                   buf_coords, state,
+                                                   shell->proximity,
+                                                   display);
+                  g_array_remove_index (shell->event_queue, 0); /* removing used event*/
+
               }
-
+              gimp_display_shell_push_event_history (shell, &image_coords);
             shell->last_read_motion_time = time;
           }
 
@@ -1778,8 +1784,90 @@
 }
 
 
+/* Event delay timeout handler & generic event flusher */
+gboolean
+gimp_display_shell_flush_event_queue (GimpDisplayShell *shell)
+{
+  gint      i            = 0;
+  GimpDisplay     *display = shell->display;
+  Gimp            *gimp    = display->gimp;
+
+  GimpTool        *active_tool = tool_manager_get_active (gimp);
+
+  shell->event_delay = FALSE;
+  if (active_tool                                        &&
+      gimp_tool_control_is_active (active_tool->control))
+    {
+      while (shell->event_queue->len > 0)
+        {
+          GimpCoords *buf_coords = &g_array_index (shell->event_queue, GimpCoords, 0);
+
+          tool_manager_motion_active (shell->display->gimp,
+                                      buf_coords,
+                                      shell->last_motion_time,
+                                      shell->last_active_state,
+                                      shell->display);
+          gimp_display_shell_push_event_history (shell, buf_coords);
+          g_array_remove_index (shell->event_queue, 0); /* removing used event*/
+          i++;
+        }
+    }
+  else
+    {
+      /*If we have nowhere sane to put the events, dump them*/
+      g_array_set_size (shell->event_queue, 0);
+    }
+
+  /* Set the timeout id to 0 and return false so a potential timeout calling it gets removed */
+  shell->event_delay_timeout = 0;
+
+  return FALSE;
+}
+
+
 /*  private functions  */
+static void
+gimp_display_shell_process_tool_event_queue (GimpDisplayShell *shell,
+                                             GdkModifierType   state,
+                                             guint32           time)
+{
+  gint i = 0;
+  gint keep = 0;
+  GdkModifierType event_state;
 
+  if (shell->event_delay)
+    {
+      keep++; /* Holding one event in buf */
+      event_state = shell->last_active_state; /*If we are in delay we use LAST state, not current*/
+
+      if (shell->event_delay_timeout != 0) g_source_remove (shell->event_delay_timeout);
+      shell->event_delay_timeout = g_timeout_add (50, (GSourceFunc) gimp_display_shell_flush_event_queue, shell);
+    }
+  else
+    {
+      event_state = state; /* Save the state */
+      if (shell->event_delay_timeout != 0)
+        g_source_remove (shell->event_delay_timeout);
+    }
+  shell->last_active_state = state;
+
+  while (shell->event_queue->len > keep)
+    {
+      GimpCoords *buf_coords = &g_array_index (shell->event_queue, GimpCoords, 0);
+
+      tool_manager_motion_active (shell->display->gimp,
+                                  buf_coords,
+                                  time,
+                                  event_state,
+                                  shell->display);
+
+      g_array_remove_index (shell->event_queue, 0); /* removing used event*/
+      i++;
+
+    }
+
+}
+
 static void
 gimp_display_shell_vscrollbar_update (GtkAdjustment    *adjustment,
                                       GimpDisplayShell *shell)
Index: app/display/gimpdisplayshell-callbacks.h
===================================================================
--- app/display/gimpdisplayshell-callbacks.h	(revision 27571)
+++ app/display/gimpdisplayshell-callbacks.h	(working copy)
@@ -56,6 +56,7 @@
 gboolean   gimp_display_shell_nav_button_press        (GtkWidget        *widget,
                                                        GdkEventButton   *bevent,
                                                        GimpDisplayShell *shell);
+gboolean   gimp_display_shell_flush_event_queue       (GimpDisplayShell *shell);
 
 
 #endif /* __GIMP_DISPLAY_SHELL_CALLBACKS_H__ */
Index: app/display/gimpdisplayshell-coords.c
===================================================================
--- app/display/gimpdisplayshell-coords.c	(revision 27571)
+++ app/display/gimpdisplayshell-coords.c	(working copy)
@@ -27,9 +27,16 @@
 #include "gimpdisplayshell.h"
 #include "gimpdisplayshell-coords.h"
 
+#include "core/gimpcoords-interpolate.h"
+
 /* Velocity unit is screen pixels per millisecond we pass to tools as 1. */
 #define VELOCITY_UNIT 3.0
 
+#define EVENT_FILL_PRECISION 4.0
+
+static void gimp_display_shell_interpolate_stroke (GimpDisplayShell *shell,
+                                                   GimpCoords       *coords);
+
 /*  public functions  */
 
 gboolean
@@ -210,13 +217,14 @@
 gboolean
 gimp_display_shell_eval_event (GimpDisplayShell *shell,
                                GimpCoords       *coords,
-			       gdouble           inertia_factor,
-			       guint32           time)
+                               gdouble           inertia_factor,
+			                         guint32           time)
 {
-  gdouble delta_time = 0.001;
-  gdouble delta_x    = 0.0;
-  gdouble delta_y    = 0.0;
-  gdouble distance   = 1.0;
+  gdouble  delta_time = 0.001;
+  gdouble  delta_x    = 0.0;
+  gdouble  delta_y    = 0.0;
+  gdouble  distance   = 1.0;
+  gboolean event_fill = (inertia_factor > 0);
 
   /* Smoothing causes problems with cursor tracking
    * when zoomed above screen resolution so we need to supress it.
@@ -340,18 +348,46 @@
           distance = sqrt (SQR (delta_x) + SQR (delta_y));
         }
 
+        /* do event fill for devices that do not provide enough events*/
+
+        if((distance >= EVENT_FILL_PRECISION) && event_fill && (shell->event_history->len >= 2))
+          {
+            if (shell->event_delay)
+              {
+                gimp_display_shell_interpolate_stroke (shell,
+                                                     coords);
+              }
+            else
+              {
+                shell->event_delay = TRUE;
+                g_array_append_val (shell->event_queue, *coords);
+
+                return FALSE;
+              }
+          }
+        else
+          {
+            if (shell->event_delay)
+              {
+                shell->event_delay = FALSE;
+              }
+            gimp_display_shell_push_event_history (shell, coords);
+
+          }
+
 #ifdef VERBOSE
       g_printerr ("DIST: %f, DT:%f, Vel:%f, Press:%f,smooth_dd:%f, sf %f\n",
                   distance,
                   delta_time,
                   shell->last_coords.velocity,
                   coords->pressure,
-                  coords->distance - dist,
+                  distance - dist,
                   inertia_factor);
 #endif
     }
 
   shell->last_coords            = *coords;
+  g_array_append_val (shell->event_queue, *coords);
 
   shell->last_motion_time       = time;
   shell->last_motion_delta_time = delta_time;
@@ -361,3 +397,45 @@
 
   return TRUE;
 }
+
+
+/* Helper function fo managing event history */
+void
+gimp_display_shell_push_event_history (GimpDisplayShell *shell,
+                                       GimpCoords       *coords)
+{
+   if (shell->event_history->len == 4)
+     g_array_remove_index (shell->event_history, 0);
+   g_array_append_val (shell->event_history, *coords);
+}
+
+static void
+gimp_display_shell_interpolate_stroke (GimpDisplayShell *shell,
+                                       GimpCoords       *coords)
+{
+  GArray     *ret_coords;
+  gint       i          = shell->event_history->len-1;
+  GimpCoords topz;
+  /*Need to assert here that theres at exactly one event in buffer
+    or bad things can happen. this should never get called under other circumstance.*/
+  ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+
+  gimp_coords_interpolate_catmull (g_array_index (shell->event_history, GimpCoords, i-1),
+                                   g_array_index (shell->event_history, GimpCoords, i  ),
+                                   g_array_index (shell->event_queue,   GimpCoords, 0  ),
+                                   *coords,
+                                   EVENT_FILL_PRECISION/2,
+                                   &ret_coords,
+                                   NULL);
+
+  gimp_display_shell_push_event_history (shell, &g_array_index (shell->event_queue,   GimpCoords, 0)); /*Push the last actual event in history*/
+  g_array_remove_index (shell->event_queue, 0); /* Remove the event you interpolate for. */
+
+  for (i = 0; i < ret_coords->len; i++)
+    {
+      GimpCoords ret_val = g_array_index (ret_coords, GimpCoords, i);
+      g_array_append_val (shell->event_queue, ret_val);
+      //printf("retsample %d: (%f, %f) p:%f\n", i, ret_val.x, ret_val.y, ret_val.pressure);
+    }
+
+}
Index: app/display/gimpdisplayshell-coords.h
===================================================================
--- app/display/gimpdisplayshell-coords.h	(revision 27571)
+++ app/display/gimpdisplayshell-coords.h	(working copy)
@@ -20,28 +20,30 @@
 #define __GIMP_DISPLAY_SHELL_COORDS_H__
 
 
-gboolean gimp_display_shell_get_event_coords  (GimpDisplayShell *shell,
-                                               GdkEvent         *event,
-                                               GdkDevice        *device,
-                                               GimpCoords       *coords);
-void     gimp_display_shell_get_device_coords (GimpDisplayShell *shell,
-                                               GdkDevice        *device,
-                                               GimpCoords       *coords);
-void     gimp_display_shell_get_time_coords   (GimpDisplayShell *shell,
-                                               GdkDevice        *device,
-                                               GdkTimeCoord     *event,
-                                               GimpCoords       *coords);
-gboolean gimp_display_shell_get_event_state   (GimpDisplayShell *shell,
-                                               GdkEvent         *event,
-                                               GdkDevice        *device,
-                                               GdkModifierType  *state);
-void     gimp_display_shell_get_device_state  (GimpDisplayShell *shell,
-                                               GdkDevice        *device,
-                                               GdkModifierType  *state);
-gboolean gimp_display_shell_eval_event        (GimpDisplayShell *shell,
-                                               GimpCoords       *coords,
-                                               gdouble           inertia_factor,
-                                               guint32           time);
+gboolean gimp_display_shell_get_event_coords   (GimpDisplayShell *shell,
+                                                GdkEvent         *event,
+                                                GdkDevice        *device,
+                                                GimpCoords       *coords);
+void     gimp_display_shell_get_device_coords  (GimpDisplayShell *shell,
+                                                GdkDevice        *device,
+                                                GimpCoords       *coords);
+void     gimp_display_shell_get_time_coords    (GimpDisplayShell *shell,
+                                                GdkDevice        *device,
+                                                GdkTimeCoord     *event,
+                                                GimpCoords       *coords);
+gboolean gimp_display_shell_get_event_state    (GimpDisplayShell *shell,
+                                                GdkEvent         *event,
+                                                GdkDevice        *device,
+                                                GdkModifierType  *state);
+void     gimp_display_shell_get_device_state   (GimpDisplayShell *shell,
+                                                GdkDevice        *device,
+                                                GdkModifierType  *state);
+gboolean gimp_display_shell_eval_event         (GimpDisplayShell *shell,
+                                                GimpCoords       *coords,
+                                                gdouble           inertia_factor,
+                                                guint32           time);
+void     gimp_display_shell_push_event_history (GimpDisplayShell *shell,
+                                                GimpCoords       *coords);
 
 
 #endif /* __GIMP_DISPLAY_SHELL_COORDS_H__ */
Index: app/Makefile.am
===================================================================
--- app/Makefile.am	(revision 27571)
+++ app/Makefile.am	(working copy)
@@ -100,6 +100,7 @@
 	-u $(SYMPREFIX)xcf_init				\
 	-u $(SYMPREFIX)internal_procs_init		\
 	-u $(SYMPREFIX)gimp_coords_interpolate_bezier	\
+ 	-u $(SYMPREFIX)gimp_coords_interpolate_bezier	\
 	-u $(SYMPREFIX)gimp_curve_map_pixels		\
 	-u $(SYMPREFIX)gimp_image_map_config_get_type	\
 	-u $(SYMPREFIX)gimp_plug_in_manager_restore
