Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 594 insertions, 0 deletions

diff --git a/app/display/gimpmotionbuffer.c b/app/display/gimpmotionbuffer.c
new file mode 100644
index 0000000..549f6f0
--- /dev/null
+++ b/app/display/gimpmotionbuffer.c
@@ -0,0 +1,594 @@
+/* GIMP - The GNU 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 3 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, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpmath/gimpmath.h"
+
+#include "display-types.h"
+
+#include "core/gimpcoords.h"
+#include "core/gimpcoords-interpolate.h"
+#include "core/gimpmarshal.h"
+
+#include "gimpmotionbuffer.h"
+
+
+/* Velocity unit is screen pixels per millisecond we pass to tools as 1. */
+#define VELOCITY_UNIT        3.0
+#define EVENT_FILL_PRECISION 6.0
+#define DIRECTION_RADIUS     (1.0 / MAX (scale_x, scale_y))
+#define SMOOTH_FACTOR        0.3
+
+
+enum
+{
+  PROP_0
+};
+
+enum
+{
+  STROKE,
+  HOVER,
+  LAST_SIGNAL
+};
+
+
+/*  local function prototypes  */
+
+static void     gimp_motion_buffer_dispose             (GObject          *object);
+static void     gimp_motion_buffer_finalize            (GObject          *object);
+static void     gimp_motion_buffer_set_property        (GObject          *object,
+                                                        guint             property_id,
+                                                        const GValue     *value,
+                                                        GParamSpec       *pspec);
+static void     gimp_motion_buffer_get_property        (GObject          *object,
+                                                        guint             property_id,
+                                                        GValue           *value,
+                                                        GParamSpec       *pspec);
+
+static void     gimp_motion_buffer_push_event_history  (GimpMotionBuffer *buffer,
+                                                        const GimpCoords *coords);
+static void     gimp_motion_buffer_pop_event_queue     (GimpMotionBuffer *buffer,
+                                                        GimpCoords       *coords);
+
+static void     gimp_motion_buffer_interpolate_stroke  (GimpMotionBuffer *buffer,
+                                                        GimpCoords       *coords);
+static gboolean gimp_motion_buffer_event_queue_timeout (GimpMotionBuffer *buffer);
+
+
+G_DEFINE_TYPE (GimpMotionBuffer, gimp_motion_buffer, GIMP_TYPE_OBJECT)
+
+#define parent_class gimp_motion_buffer_parent_class
+
+static guint motion_buffer_signals[LAST_SIGNAL] = { 0 };
+
+
+static void
+gimp_motion_buffer_class_init (GimpMotionBufferClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  motion_buffer_signals[STROKE] =
+    g_signal_new ("stroke",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (GimpMotionBufferClass, stroke),
+                  NULL, NULL,
+                  gimp_marshal_VOID__POINTER_UINT_FLAGS,
+                  G_TYPE_NONE, 3,
+                  G_TYPE_POINTER,
+                  G_TYPE_UINT,
+                  GDK_TYPE_MODIFIER_TYPE);
+
+  motion_buffer_signals[HOVER] =
+    g_signal_new ("hover",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_FIRST,
+                  G_STRUCT_OFFSET (GimpMotionBufferClass, hover),
+                  NULL, NULL,
+                  gimp_marshal_VOID__POINTER_FLAGS_BOOLEAN,
+                  G_TYPE_NONE, 3,
+                  G_TYPE_POINTER,
+                  GDK_TYPE_MODIFIER_TYPE,
+                  G_TYPE_BOOLEAN);
+
+  object_class->dispose      = gimp_motion_buffer_dispose;
+  object_class->finalize     = gimp_motion_buffer_finalize;
+  object_class->set_property = gimp_motion_buffer_set_property;
+  object_class->get_property = gimp_motion_buffer_get_property;
+}
+
+static void
+gimp_motion_buffer_init (GimpMotionBuffer *buffer)
+{
+  buffer->event_history = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+  buffer->event_queue   = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+}
+
+static void
+gimp_motion_buffer_dispose (GObject *object)
+{
+  GimpMotionBuffer *buffer = GIMP_MOTION_BUFFER (object);
+
+  if (buffer->event_delay_timeout)
+    {
+      g_source_remove (buffer->event_delay_timeout);
+      buffer->event_delay_timeout = 0;
+    }
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+gimp_motion_buffer_finalize (GObject *object)
+{
+  GimpMotionBuffer *buffer = GIMP_MOTION_BUFFER (object);
+
+  if (buffer->event_history)
+    {
+      g_array_free (buffer->event_history, TRUE);
+      buffer->event_history = NULL;
+    }
+
+  if (buffer->event_queue)
+    {
+      g_array_free (buffer->event_queue, TRUE);
+      buffer->event_queue = NULL;
+    }
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_motion_buffer_set_property (GObject      *object,
+                                 guint         property_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+  switch (property_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_motion_buffer_get_property (GObject    *object,
+                                 guint       property_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  switch (property_id)
+    {
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+
+/*  public functions  */
+
+GimpMotionBuffer *
+gimp_motion_buffer_new (void)
+{
+  return g_object_new (GIMP_TYPE_MOTION_BUFFER,
+                       NULL);
+}
+
+void
+gimp_motion_buffer_begin_stroke (GimpMotionBuffer *buffer,
+                                 guint32           time,
+                                 GimpCoords       *last_motion)
+{
+  g_return_if_fail (GIMP_IS_MOTION_BUFFER (buffer));
+  g_return_if_fail (last_motion != NULL);
+
+  buffer->last_read_motion_time = time;
+
+  *last_motion = buffer->last_coords;
+}
+
+void
+gimp_motion_buffer_end_stroke (GimpMotionBuffer *buffer)
+{
+  g_return_if_fail (GIMP_IS_MOTION_BUFFER (buffer));
+
+  if (buffer->event_delay_timeout)
+    {
+      g_source_remove (buffer->event_delay_timeout);
+      buffer->event_delay_timeout = 0;
+    }
+
+  gimp_motion_buffer_event_queue_timeout (buffer);
+}
+
+/**
+ * gimp_motion_buffer_motion_event:
+ * @buffer:
+ * @coords:
+ * @time:
+ * @event_fill:
+ *
+ * This function evaluates the event to decide if the change is big
+ * enough to need handling and returns FALSE, if change is less than
+ * set filter level taking a whole lot of load off any draw tools that
+ * have no use for these events anyway. If the event is seen fit at
+ * first look, it is evaluated for speed and smoothed.  Due to lousy
+ * time resolution of events pretty strong smoothing is applied to
+ * timestamps for sensible speed result. This function is also ideal
+ * for other event adjustment like pressure curve or calculating other
+ * derived dynamics factors like angular velocity calculation from
+ * tilt values, to allow for even more dynamic brushes. Calculated
+ * distance to last event is stored in GimpCoords because its a
+ * sideproduct of velocity calculation and is currently calculated in
+ * each tool. If they were to use this distance, more resources on
+ * recalculating the same value would be saved.
+ *
+ * Return value: %TRUE if the motion was significant enough to be
+ *               processed, %FALSE otherwise.
+ **/
+gboolean
+gimp_motion_buffer_motion_event (GimpMotionBuffer *buffer,
+                                 GimpCoords       *coords,
+                                 guint32           time,
+                                 gboolean          event_fill)
+{
+  gdouble  delta_time  = 0.001;
+  gdouble  delta_x     = 0.0;
+  gdouble  delta_y     = 0.0;
+  gdouble  distance    = 1.0;
+  gdouble  scale_x     = coords->xscale;
+  gdouble  scale_y     = coords->yscale;
+
+  g_return_val_if_fail (GIMP_IS_MOTION_BUFFER (buffer), FALSE);
+  g_return_val_if_fail (coords != NULL, FALSE);
+
+  /*  the last_read_motion_time most be set unconditionally, so set
+   *  it early
+   */
+  buffer->last_read_motion_time = time;
+
+  delta_time = (buffer->last_motion_delta_time * (1 - SMOOTH_FACTOR) +
+                (time - buffer->last_motion_time) * SMOOTH_FACTOR);
+
+  if (buffer->last_motion_time == 0)
+    {
+      /*  First pair is invalid to do any velocity calculation, so we
+       *  apply a constant value.
+       */
+      coords->velocity = 1.0;
+    }
+  else
+    {
+      GimpCoords last_dir_event = buffer->last_coords;
+      gdouble    filter;
+      gdouble    dist;
+      gdouble    delta_dir;
+      gdouble    dir_delta_x = 0.0;
+      gdouble    dir_delta_y = 0.0;
+
+      delta_x = last_dir_event.x - coords->x;
+      delta_y = last_dir_event.y - coords->y;
+
+      /*  Events with distances less than the screen resolution are
+       *  not worth handling.
+       */
+      filter = MIN (1.0 / scale_x, 1.0 / scale_y) / 2.0;
+
+      if (fabs (delta_x) < filter &&
+          fabs (delta_y) < filter)
+        {
+          return FALSE;
+        }
+
+      distance = dist = sqrt (SQR (delta_x) + SQR (delta_y));
+
+      /*  If even smoothed time resolution does not allow to guess for
+       *  speed, use last velocity.
+       */
+      if (delta_time == 0)
+        {
+          coords->velocity = buffer->last_coords.velocity;
+        }
+      else
+        {
+          /*  We need to calculate the velocity in screen coordinates
+           *  for human interaction
+           */
+          gdouble screen_distance = (distance * MIN (scale_x, scale_y));
+
+          /* Calculate raw valocity */
+          coords->velocity = ((screen_distance / delta_time) / VELOCITY_UNIT);
+
+          /* Adding velocity dependent smoothing, feels better in tools. */
+          coords->velocity = (buffer->last_coords.velocity *
+                              (1 - MIN (SMOOTH_FACTOR, coords->velocity)) +
+                              coords->velocity *
+                              MIN (SMOOTH_FACTOR, coords->velocity));
+
+          /* Speed needs upper limit */
+          coords->velocity = MIN (coords->velocity, 1.0);
+        }
+
+      if (((fabs (delta_x) > DIRECTION_RADIUS) &&
+           (fabs (delta_y) > DIRECTION_RADIUS)) ||
+          (buffer->event_history->len < 4))
+        {
+          dir_delta_x = delta_x;
+          dir_delta_y = delta_y;
+        }
+      else
+        {
+          gint x = CLAMP ((buffer->event_history->len - 1), 3, 15);
+
+          while (((fabs (dir_delta_x) < DIRECTION_RADIUS) ||
+                  (fabs (dir_delta_y) < DIRECTION_RADIUS)) &&
+                 (x >= 0))
+            {
+              last_dir_event = g_array_index (buffer->event_history,
+                                              GimpCoords, x);
+
+              dir_delta_x = last_dir_event.x - coords->x;
+              dir_delta_y = last_dir_event.y - coords->y;
+
+              x--;
+            }
+        }
+
+      if ((fabs (dir_delta_x) < DIRECTION_RADIUS) ||
+          (fabs (dir_delta_y) < DIRECTION_RADIUS))
+        {
+          coords->direction = buffer->last_coords.direction;
+        }
+      else
+        {
+          coords->direction = gimp_coords_direction (&last_dir_event, coords);
+        }
+
+      coords->direction = coords->direction - floor (coords->direction);
+
+      delta_dir = coords->direction - buffer->last_coords.direction;
+
+      if (delta_dir < -0.5)
+        {
+          coords->direction = (0.5 * coords->direction +
+                               0.5 * (buffer->last_coords.direction - 1.0));
+        }
+      else if (delta_dir > 0.5)
+        {
+          coords->direction = (0.5 * coords->direction +
+                               0.5 * (buffer->last_coords.direction + 1.0));
+        }
+      else
+        {
+          coords->direction = (0.5 * coords->direction +
+                               0.5 * buffer->last_coords.direction);
+        }
+
+      coords->direction = coords->direction - floor (coords->direction);
+
+      /* do event fill for devices that do not provide enough events */
+      if (distance >= EVENT_FILL_PRECISION &&
+          event_fill                       &&
+          buffer->event_history->len >= 2)
+        {
+          if (buffer->event_delay)
+            {
+              gimp_motion_buffer_interpolate_stroke (buffer, coords);
+            }
+          else
+            {
+              buffer->event_delay = TRUE;
+              gimp_motion_buffer_push_event_history (buffer, coords);
+            }
+        }
+      else
+        {
+          if (buffer->event_delay)
+            buffer->event_delay = FALSE;
+
+          gimp_motion_buffer_push_event_history (buffer, coords);
+        }
+
+#ifdef EVENT_VERBOSE
+      g_printerr ("DIST: %f, DT:%f, Vel:%f, Press:%f,smooth_dd:%f, POS: (%f, %f)\n",
+                  distance,
+                  delta_time,
+                  buffer->last_coords.velocity,
+                  coords->pressure,
+                  distance - dist,
+                  coords->x,
+                  coords->y);
+#endif
+    }
+
+  g_array_append_val (buffer->event_queue, *coords);
+
+  buffer->last_coords            = *coords;
+  buffer->last_motion_time       = time;
+  buffer->last_motion_delta_time = delta_time;
+  buffer->last_motion_delta_x    = delta_x;
+  buffer->last_motion_delta_y    = delta_y;
+  buffer->last_motion_distance   = distance;
+
+  return TRUE;
+}
+
+guint32
+gimp_motion_buffer_get_last_motion_time (GimpMotionBuffer *buffer)
+{
+  g_return_val_if_fail (GIMP_IS_MOTION_BUFFER (buffer), 0);
+
+  return buffer->last_read_motion_time;
+}
+
+void
+gimp_motion_buffer_request_stroke (GimpMotionBuffer *buffer,
+                                   GdkModifierType   state,
+                                   guint32           time)
+{
+  GdkModifierType  event_state;
+  gint             keep = 0;
+
+  g_return_if_fail (GIMP_IS_MOTION_BUFFER (buffer));
+
+  if (buffer->event_delay)
+    {
+      /* If we are in delay we use LAST state, not current */
+      event_state = buffer->last_active_state;
+
+      keep = 1; /* Holding one event in buf */
+    }
+  else
+    {
+      /* Save the state */
+      event_state = state;
+    }
+
+  if (buffer->event_delay_timeout)
+    {
+      g_source_remove (buffer->event_delay_timeout);
+      buffer->event_delay_timeout = 0;
+    }
+
+  buffer->last_active_state = state;
+
+  while (buffer->event_queue->len > keep)
+    {
+      GimpCoords buf_coords;
+
+      gimp_motion_buffer_pop_event_queue (buffer, &buf_coords);
+
+      g_signal_emit (buffer, motion_buffer_signals[STROKE], 0,
+                     &buf_coords, time, event_state);
+    }
+
+  if (buffer->event_delay)
+    {
+      buffer->event_delay_timeout =
+        g_timeout_add (50,
+                       (GSourceFunc) gimp_motion_buffer_event_queue_timeout,
+                       buffer);
+    }
+}
+
+void
+gimp_motion_buffer_request_hover (GimpMotionBuffer *buffer,
+                                  GdkModifierType   state,
+                                  gboolean          proximity)
+{
+  g_return_if_fail (GIMP_IS_MOTION_BUFFER (buffer));
+
+  if (buffer->event_queue->len > 0)
+    {
+      GimpCoords buf_coords = g_array_index (buffer->event_queue,
+                                             GimpCoords,
+                                             buffer->event_queue->len - 1);
+
+      g_signal_emit (buffer, motion_buffer_signals[HOVER], 0,
+                     &buf_coords, state, proximity);
+
+      g_array_set_size (buffer->event_queue, 0);
+    }
+}
+
+
+/*  private functions  */
+
+static void
+gimp_motion_buffer_push_event_history (GimpMotionBuffer *buffer,
+                                       const GimpCoords *coords)
+{
+  if (buffer->event_history->len == 4)
+    g_array_remove_index (buffer->event_history, 0);
+
+  g_array_append_val (buffer->event_history, *coords);
+}
+
+static void
+gimp_motion_buffer_pop_event_queue (GimpMotionBuffer *buffer,
+                                    GimpCoords       *coords)
+{
+  *coords = g_array_index (buffer->event_queue, GimpCoords, 0);
+
+  g_array_remove_index (buffer->event_queue, 0);
+}
+
+static void
+gimp_motion_buffer_interpolate_stroke (GimpMotionBuffer *buffer,
+                                       GimpCoords       *coords)
+{
+  GimpCoords  catmull[4];
+  GArray     *ret_coords;
+  gint        i = buffer->event_history->len - 1;
+
+  /* Note that there must be exactly one event in buffer or bad things
+   * can happen. This must never get called under other circumstances.
+   */
+  ret_coords = g_array_new (FALSE, FALSE, sizeof (GimpCoords));
+
+  catmull[0] = g_array_index (buffer->event_history, GimpCoords, i - 1);
+  catmull[1] = g_array_index (buffer->event_history, GimpCoords, i);
+  catmull[2] = g_array_index (buffer->event_queue,   GimpCoords, 0);
+  catmull[3] = *coords;
+
+  gimp_coords_interpolate_catmull (catmull, EVENT_FILL_PRECISION / 2,
+                                   ret_coords, NULL);
+
+  /* Push the last actual event in history */
+  gimp_motion_buffer_push_event_history (buffer,
+                                         &g_array_index (buffer->event_queue,
+                                                         GimpCoords, 0));
+
+  g_array_set_size (buffer->event_queue, 0);
+
+  g_array_append_vals (buffer->event_queue,
+                       &g_array_index (ret_coords, GimpCoords, 0),
+                       ret_coords->len);
+
+  g_array_free (ret_coords, TRUE);
+}
+
+static gboolean
+gimp_motion_buffer_event_queue_timeout (GimpMotionBuffer *buffer)
+{
+  buffer->event_delay         = FALSE;
+  buffer->event_delay_timeout = 0;
+
+  if (buffer->event_queue->len > 0)
+    {
+      GimpCoords last_coords = g_array_index (buffer->event_queue,
+                                              GimpCoords,
+                                              buffer->event_queue->len - 1);
+
+      gimp_motion_buffer_push_event_history (buffer, &last_coords);
+
+      gimp_motion_buffer_request_stroke (buffer,
+                                         buffer->last_active_state,
+                                         buffer->last_read_motion_time);
+    }
+
+  return FALSE;
+}