summaryrefslogtreecommitdiffstats
path: root/app/display/gimpmotionbuffer.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 03:13:10 +0000
commit3c57dd931145d43f2b0aef96c4d178135956bf91 (patch)
tree3de698981e9f0cc2c4f9569b19a5f3595e741f6b /app/display/gimpmotionbuffer.c
parentInitial commit. (diff)
downloadgimp-3c57dd931145d43f2b0aef96c4d178135956bf91.tar.xz
gimp-3c57dd931145d43f2b0aef96c4d178135956bf91.zip
Adding upstream version 2.10.36.upstream/2.10.36
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'app/display/gimpmotionbuffer.c')
-rw-r--r--app/display/gimpmotionbuffer.c594
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;
+}