gimp r27898 - in trunk: . app/core app/display
- From: neo svn gnome org
- To: svn-commits-list gnome org
- Subject: gimp r27898 - in trunk: . app/core app/display
- Date: Sat, 10 Jan 2009 00:48:30 +0000 (UTC)
Author: neo
Date: Sat Jan 10 00:48:30 2009
New Revision: 27898
URL: http://svn.gnome.org/viewvc/gimp?rev=27898&view=rev
Log:
2009-01-10 Sven Neumann <sven gimp org>
Bug 471344 â Circular brush strokes are not smooth and have
corners
Bug 127785 â stroking with size linked to pressure sensitivity
should scale the spacing
* app/core/gimpcoords-interpolate.[ch]
* app/display/gimpdisplayshell.[ch]
* app/display/gimpdisplayshell-callbacks.[ch]
* app/display/gimpdisplayshell-coords.[ch]: applied patch from
Alexia Death that introduces a Catmul-Rom splines based event
interpolation and also adapts the brush spacing to brush size.
Modified:
trunk/ChangeLog
trunk/app/core/gimpcoords-interpolate.c
trunk/app/core/gimpcoords-interpolate.h
trunk/app/display/gimpdisplayshell-callbacks.c
trunk/app/display/gimpdisplayshell-callbacks.h
trunk/app/display/gimpdisplayshell-coords.c
trunk/app/display/gimpdisplayshell-coords.h
trunk/app/display/gimpdisplayshell.c
trunk/app/display/gimpdisplayshell.h
Modified: trunk/app/core/gimpcoords-interpolate.c
==============================================================================
--- trunk/app/core/gimpcoords-interpolate.c (original)
+++ trunk/app/core/gimpcoords-interpolate.c Sat Jan 10 00:48:30 2009
@@ -29,6 +29,7 @@
#include "gimpcoords.h"
#include "gimpcoords-interpolate.h"
+
/* Local helper functions declarations*/
static void gimp_coords_interpolate_bezier_internal (const GimpCoords bezier_pt1,
const GimpCoords bezier_pt2,
@@ -40,6 +41,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 */
@@ -190,7 +196,7 @@
const GimpCoords bezier_pt2,
const GimpCoords bezier_pt3,
const GimpCoords bezier_pt4,
- gdouble precision)
+ gdouble precision)
{
GimpCoords pt1, pt2;
@@ -208,3 +214,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 velocity;
+ 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);
+
+ 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);
+
+ velocity = gimp_coords_get_catmull_spline_point (p,
+ past_coords.velocity,
+ start_coords.velocity,
+ end_coords.velocity,
+ future_coords.velocity);
+ res_coords.velocity = CLAMP (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);
+}
Modified: trunk/app/core/gimpcoords-interpolate.h
==============================================================================
--- trunk/app/core/gimpcoords-interpolate.h (original)
+++ trunk/app/core/gimpcoords-interpolate.h Sat Jan 10 00:48:30 2009
@@ -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__ */
Modified: trunk/app/display/gimpdisplayshell-callbacks.c
==============================================================================
--- trunk/app/display/gimpdisplayshell-callbacks.c (original)
+++ trunk/app/display/gimpdisplayshell-callbacks.c Sat Jan 10 00:48:30 2009
@@ -47,6 +47,7 @@
#include "tools/gimppainttool.h"
#include "tools/gimptoolcontrol.h"
#include "tools/tool_manager.h"
+#include "tools/tools-enums.h"
#include "widgets/gimpcontrollers.h"
#include "widgets/gimpcontrollerkeyboard.h"
@@ -80,28 +81,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 gboolean gimp_display_shell_hscrollbar_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 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 +1006,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,
@@ -1253,8 +1261,11 @@
{
gint i;
+ tool_manager_control_active (gimp, GIMP_TOOL_ACTION_PAUSE, display);
+
for (i = 0; i < n_history_events; i++)
{
+
gimp_display_shell_get_time_coords (shell,
mevent->device,
history_events[i],
@@ -1286,20 +1297,21 @@
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;
}
+ tool_manager_control_active (gimp, GIMP_TOOL_ACTION_RESUME, display);
+
gdk_device_free_history (history_events, n_history_events);
}
else
{
+
/* Early removal of useless events saves CPU time.
*/
if (gimp_display_shell_eval_event (shell,
@@ -1307,11 +1319,9 @@
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 +1335,25 @@
/* 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);
+ /* remove used event */
+ g_array_remove_index (shell->event_queue, 0);
+
}
+ gimp_display_shell_push_event_history (shell, &image_coords);
shell->last_read_motion_time = time;
}
@@ -1778,7 +1796,97 @@
}
+/* Event delay timeout handler & generic event flusher */
+gboolean
+gimp_display_shell_flush_event_queue (GimpDisplayShell *shell)
+{
+
+ GimpTool *active_tool = tool_manager_get_active (shell->display->gimp);
+
+ shell->event_delay = FALSE;
+
+ /* Set the timeout id to 0 */
+ shell->event_delay_timeout = 0;
+
+ if (active_tool &&
+ gimp_tool_control_is_active (active_tool->control) &&
+ shell->event_queue->len > 0)
+ {
+ GimpCoords last_coords = g_array_index (shell->event_queue,
+ GimpCoords, shell->event_queue->len - 1 );
+
+ gimp_display_shell_push_event_history (shell, &last_coords);
+
+ gimp_display_shell_process_tool_event_queue (shell,
+ shell->last_active_state,
+ shell->last_read_motion_time);
+ }
+
+ /* Return false so a potential timeout calling it gets removed */
+ return FALSE;
+}
+
+
/* private functions */
+static void
+gimp_display_shell_process_tool_event_queue (GimpDisplayShell *shell,
+ GdkModifierType state,
+ guint32 time)
+{
+ gint i;
+ gint keep = 0;
+ GdkModifierType event_state;
+ GimpCoords keep_event;
+ GimpCoords *buf_coords = NULL;
+
+ if (shell->event_delay)
+ {
+ keep = 1; /* Holding one event in buf */
+ /* If we are in delay we use LAST state, not current */
+ event_state = shell->last_active_state;
+ keep_event = g_array_index (shell->event_queue,
+ GimpCoords, shell->event_queue->len - 1 );
+ }
+ 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;
+
+ tool_manager_control_active (shell->display->gimp,
+ GIMP_TOOL_ACTION_PAUSE, shell->display);
+
+ for (i = 0; i < (shell->event_queue->len - keep); i++)
+ {
+ buf_coords = &g_array_index (shell->event_queue, GimpCoords, i);
+
+ tool_manager_motion_active (shell->display->gimp,
+ buf_coords,
+ time,
+ event_state,
+ shell->display);
+
+ }
+
+ tool_manager_control_active (shell->display->gimp,
+ GIMP_TOOL_ACTION_RESUME, shell->display);
+
+ g_array_set_size (shell->event_queue, 0);
+
+ if (shell->event_delay)
+ {
+ g_array_append_val (shell->event_queue, keep_event);
+
+ shell->event_delay_timeout =
+ g_timeout_add (50,
+ (GSourceFunc) gimp_display_shell_flush_event_queue,
+ shell);
+ }
+}
static void
gimp_display_shell_vscrollbar_update (GtkAdjustment *adjustment,
Modified: trunk/app/display/gimpdisplayshell-callbacks.h
==============================================================================
--- trunk/app/display/gimpdisplayshell-callbacks.h (original)
+++ trunk/app/display/gimpdisplayshell-callbacks.h Sat Jan 10 00:48:30 2009
@@ -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__ */
Modified: trunk/app/display/gimpdisplayshell-coords.c
==============================================================================
--- trunk/app/display/gimpdisplayshell-coords.c (original)
+++ trunk/app/display/gimpdisplayshell-coords.c Sat Jan 10 00:48:30 2009
@@ -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 6.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,48 @@
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;
+
+ }
+ }
+ 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 +399,51 @@
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;
+
+ /* Note that there must be exactly one event in buffer or bad things
+ * can happen. This should never get called under other circumstances.
+ */
+ 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);
+
+ /* Push the last actual event in history */
+ gimp_display_shell_push_event_history (shell,
+ &g_array_index (shell->event_queue,
+ GimpCoords, 0));
+
+ g_array_set_size(shell->event_queue, 0);
+
+ g_array_append_vals (shell->event_queue,
+ &g_array_index (ret_coords, GimpCoords, 0),
+ ret_coords->len);
+
+ g_array_free(ret_coords, TRUE);
+}
Modified: trunk/app/display/gimpdisplayshell-coords.h
==============================================================================
--- trunk/app/display/gimpdisplayshell-coords.h (original)
+++ trunk/app/display/gimpdisplayshell-coords.h Sat Jan 10 00:48:30 2009
@@ -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__ */
Modified: trunk/app/display/gimpdisplayshell.c
==============================================================================
--- trunk/app/display/gimpdisplayshell.c (original)
+++ trunk/app/display/gimpdisplayshell.c Sat Jan 10 00:48:30 2009
@@ -82,7 +82,6 @@
#include "gimp-intl.h"
-
enum
{
PROP_0,
@@ -356,6 +355,17 @@
shell->highlight = NULL;
shell->mask = NULL;
+ shell->event_history = g_array_new (FALSE, FALSE,
+ sizeof (GimpCoords));
+ 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);
@@ -498,6 +508,18 @@
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);
Modified: trunk/app/display/gimpdisplayshell.h
==============================================================================
--- trunk/app/display/gimpdisplayshell.h (original)
+++ trunk/app/display/gimpdisplayshell.h Sat Jan 10 00:48:30 2009
@@ -206,6 +206,14 @@
GdkRectangle *highlight; /* in image coordinates, can be NULL */
GimpDrawable *mask;
GimpChannelType mask_color;
+
+ GArray *event_history;
+ GArray *event_queue;
+ gboolean event_delay; /* TRUE if theres an unsent event in
+ the history buffer */
+
+ gint event_delay_timeout;
+ GdkModifierType last_active_state;
};
struct _GimpDisplayShellClass
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
