dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/display/gimpdisplayshell-tool-events.c

1812 lines
62 KiB
C
Raw Normal View History

app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* 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 <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <gegl.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "display-types.h"
#include "tools/tools-types.h"
#include "config/gimpdisplayconfig.h"
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "widgets/gimpcontrollers.h"
#include "widgets/gimpcontrollerkeyboard.h"
Add a controller for binding mouse buttons
2011-04-07 05:12:32 +08:00
#include "widgets/gimpcontrollermouse.h"
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
#include "widgets/gimpcontrollerwheel.h"
#include "widgets/gimpdeviceinfo.h"
#include "widgets/gimpdeviceinfo-coords.h"
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
#include "widgets/gimpdevicemanager.h"
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
#include "widgets/gimpdevices.h"
#include "widgets/gimpdialogfactory.h"
#include "widgets/gimpuimanager.h"
app: forgot to #include "widgets/gimpwidgets-utils.h"
2011-02-24 23:54:39 +08:00
#include "widgets/gimpwidgets-utils.h"
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
#include "tools/gimpimagemaptool.h"
#include "tools/gimpmovetool.h"
#include "tools/gimppainttool.h"
#include "tools/gimptoolcontrol.h"
#include "tools/tool_manager.h"
#include "gimpdisplay.h"
#include "gimpdisplayshell.h"
#include "gimpdisplayshell-autoscroll.h"
#include "gimpdisplayshell-cursor.h"
#include "gimpdisplayshell-grab.h"
#include "gimpdisplayshell-layer-select.h"
#include "gimpdisplayshell-scale.h"
#include "gimpdisplayshell-scroll.h"
#include "gimpdisplayshell-tool-events.h"
#include "gimpdisplayshell-transform.h"
#include "gimpimagewindow.h"
app: add GimpMotionBuffer class to swallow all the event smoothing code This commit only adds the class and removes the members from GimpDisplayShell, so everything looks more ugly than before, but I wanted the member moving separate from any refactorings.
2011-04-18 00:53:42 +08:00
#include "gimpmotionbuffer.h"
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
#include "gimp-log.h"
/* local function prototypes */
static GdkModifierType
gimp_display_shell_key_to_state (gint key);
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
static void gimp_display_shell_proximity_in (GimpDisplayShell *shell);
static void gimp_display_shell_proximity_out (GimpDisplayShell *shell);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void gimp_display_shell_check_device_cursor (GimpDisplayShell *shell);
static void gimp_display_shell_start_scrolling (GimpDisplayShell *shell,
gint x,
gint y);
static void gimp_display_shell_stop_scrolling (GimpDisplayShell *shell);
static void gimp_display_shell_space_pressed (GimpDisplayShell *shell,
GdkEvent *event);
static void gimp_display_shell_space_released (GimpDisplayShell *shell,
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
GdkEvent *event,
const GimpCoords *image_coords);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void gimp_display_shell_update_focus (GimpDisplayShell *shell,
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gboolean focus_in,
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
const GimpCoords *image_coords,
GdkModifierType state);
static void gimp_display_shell_update_cursor (GimpDisplayShell *shell,
const GimpCoords *display_coords,
const GimpCoords *image_coords,
GdkModifierType state,
gboolean update_software_cursor);
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
static gboolean gimp_display_shell_initialize_tool (GimpDisplayShell *shell,
const GimpCoords *image_coords,
GdkModifierType state);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void gimp_display_shell_get_event_coords (GimpDisplayShell *shell,
GdkEvent *event,
GimpCoords *display_coords,
GdkModifierType *state,
guint32 *time);
static void gimp_display_shell_untransform_event_coords (GimpDisplayShell *shell,
const GimpCoords *display_coords,
GimpCoords *image_coords,
gboolean *update_software_cursor);
static void gimp_display_shell_toggle_hide_docks (GimpDisplayShell *shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static GdkEvent * gimp_display_shell_compress_motion (GimpDisplayShell *shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* public functions */
gboolean
gimp_display_shell_events (GtkWidget *widget,
GdkEvent *event,
GimpDisplayShell *shell)
{
Gimp *gimp;
gboolean set_display = FALSE;
/* are we in destruction? */
if (! shell->display || ! gimp_display_get_shell (shell->display))
return TRUE;
gimp = gimp_display_get_gimp (shell->display);
switch (event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
GdkEventKey *kevent = (GdkEventKey *) event;
if (gimp->busy)
return TRUE;
/* do not process any key events while BUTTON1 is down. We do this
* so tools keep the modifier state they were in when BUTTON1 was
* pressed and to prevent accelerators from being invoked.
*/
if (kevent->state & GDK_BUTTON1_MASK)
{
if (kevent->keyval == GDK_KEY_Shift_L ||
kevent->keyval == GDK_KEY_Shift_R ||
kevent->keyval == GDK_KEY_Control_L ||
kevent->keyval == GDK_KEY_Control_R ||
kevent->keyval == GDK_KEY_Alt_L ||
kevent->keyval == GDK_KEY_Alt_R)
{
break;
}
if (event->type == GDK_KEY_PRESS)
{
if ((kevent->keyval == GDK_KEY_space ||
kevent->keyval == GDK_KEY_KP_Space) && shell->space_release_pending)
{
shell->space_pressed = TRUE;
shell->space_release_pending = FALSE;
}
}
else
{
if ((kevent->keyval == GDK_KEY_space ||
kevent->keyval == GDK_KEY_KP_Space) && shell->space_pressed)
{
shell->space_pressed = FALSE;
shell->space_release_pending = TRUE;
}
}
return TRUE;
}
switch (kevent->keyval)
{
case GDK_KEY_Left: case GDK_KEY_Right:
case GDK_KEY_Up: case GDK_KEY_Down:
case GDK_KEY_space:
case GDK_KEY_KP_Space:
case GDK_KEY_Tab:
case GDK_KEY_ISO_Left_Tab:
case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:
case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:
case GDK_KEY_Control_L: case GDK_KEY_Control_R:
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
case GDK_KEY_BackSpace:
case GDK_KEY_Escape:
break;
default:
if (shell->space_pressed)
return TRUE;
break;
}
set_display = TRUE;
break;
}
case GDK_BUTTON_PRESS:
case GDK_SCROLL:
set_display = TRUE;
break;
case GDK_FOCUS_CHANGE:
{
GdkEventFocus *fevent = (GdkEventFocus *) event;
if (fevent->in && shell->display->config->activate_on_focus)
set_display = TRUE;
}
break;
default:
break;
}
/* Setting the context's display automatically sets the image, too */
if (set_display)
gimp_context_set_display (gimp_get_user_context (gimp), shell->display);
return FALSE;
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static gboolean
gimp_display_shell_canvas_no_image_events (GtkWidget *canvas,
GdkEvent *event,
GimpDisplayShell *shell)
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
switch (event->type)
{
case GDK_BUTTON_PRESS:
{
GdkEventButton *bevent = (GdkEventButton *) event;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (bevent->button == 3)
{
gimp_ui_manager_ui_popup (shell->popup_manager,
"/dummy-menubar/image-popup",
GTK_WIDGET (shell),
NULL, NULL, NULL, NULL);
return TRUE;
}
}
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_KEY_PRESS:
{
GdkEventKey *kevent = (GdkEventKey *) event;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (kevent->keyval == GDK_KEY_Tab ||
kevent->keyval == GDK_KEY_ISO_Left_Tab)
{
gimp_display_shell_toggle_hide_docks (shell);
return TRUE;
}
}
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
default:
break;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
return FALSE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gboolean
gimp_display_shell_canvas_tool_events (GtkWidget *canvas,
GdkEvent *event,
GimpDisplayShell *shell)
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
GimpDisplay *display;
GimpImage *image;
Gimp *gimp;
GimpCoords display_coords;
GimpCoords image_coords;
GdkModifierType state;
guint32 time;
gboolean device_changed = FALSE;
gboolean return_val = FALSE;
gboolean update_sw_cursor = FALSE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
g_return_val_if_fail (gtk_widget_get_realized (canvas), FALSE);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
/* are we in destruction? */
if (! shell->display || ! gimp_display_get_shell (shell->display))
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
/* set the active display before doing any other canvas event processing */
if (gimp_display_shell_events (canvas, event, shell))
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
/* ignore events on overlays, but make sure key events go through
* anyway because they are always originating from the toplevel
*/
if (((GdkEventAny *) event)->window != gtk_widget_get_window (canvas))
{
if ((event->type != GDK_KEY_PRESS &&
event->type != GDK_KEY_RELEASE) ||
! gtk_widget_has_focus (canvas))
{
return FALSE;
}
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
display = shell->display;
gimp = gimp_display_get_gimp (display);
image = gimp_display_get_image (display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! image)
return gimp_display_shell_canvas_no_image_events (canvas, event, shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: replace a wrong G_LIKELY() by G_UNLIKELY() in tool_events()
2011-02-27 18:08:36 +08:00
GIMP_LOG (TOOL_EVENTS, "event (display %p): %s",
display, gimp_print_event (event));
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
/* Find out what device the event occurred upon */
if (! gimp->busy && gimp_devices_check_change (gimp, event))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_check_device_cursor (shell);
device_changed = TRUE;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_get_event_coords (shell, event,
&display_coords,
&state, &time);
gimp_display_shell_untransform_event_coords (shell,
&display_coords, &image_coords,
&update_sw_cursor);
/* If the device (and maybe the tool) has changed, update the new
* tool's state
*/
if (device_changed && gtk_widget_has_focus (canvas))
{
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, TRUE,
&image_coords, state);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
switch (event->type)
{
case GDK_ENTER_NOTIFY:
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
GdkEventCrossing *cevent = (GdkEventCrossing *) event;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (cevent->mode != GDK_CROSSING_NORMAL)
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
gimp_display_shell_proximity_in (shell);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
update_sw_cursor = TRUE;
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_LEAVE_NOTIFY:
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
GdkEventCrossing *cevent = (GdkEventCrossing *) event;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (cevent->mode != GDK_CROSSING_NORMAL)
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
gimp_display_shell_proximity_out (shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_PROXIMITY_IN:
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
gimp_display_shell_proximity_in (shell);
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_PROXIMITY_OUT:
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
gimp_display_shell_proximity_out (shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
break;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_FOCUS_CHANGE:
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
GdkEventFocus *fevent = (GdkEventFocus *) event;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (fevent->in)
{
if (G_UNLIKELY (! gtk_widget_has_focus (canvas)))
g_warning ("%s: FOCUS_IN but canvas has no focus", G_STRFUNC);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
/* ignore any focus changes while we have a grab */
if (shell->pointer_grabbed)
return TRUE;
/* press modifier keys when the canvas gets the focus */
gimp_display_shell_update_focus (shell, TRUE,
&image_coords, state);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
else
{
app: replace a wrong G_LIKELY() by G_UNLIKELY() in tool_events()
2011-02-27 18:08:36 +08:00
if (G_UNLIKELY (gtk_widget_has_focus (canvas)))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
g_warning ("%s: FOCUS_OUT but canvas has focus", G_STRFUNC);
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
/* ignore any focus changes while we have a grab */
if (shell->pointer_grabbed)
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* release modifier keys when the canvas loses the focus */
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, FALSE,
&image_coords, 0);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
}
break;
case GDK_BUTTON_PRESS:
{
GdkEventButton *bevent = (GdkEventButton *) event;
GdkEventMask event_mask;
GimpTool *active_tool;
/* focus the widget if it isn't; if the toplevel window
* already has focus, this will generate a FOCUS_IN on the
* canvas immediately, therefore we do this before logging
* the BUTTON_PRESS.
*/
if (! gtk_widget_has_focus (canvas))
gtk_widget_grab_focus (canvas);
/* if the toplevel window didn't have focus, the above
* gtk_widget_grab_focus() didn't set the canvas' HAS_FOCUS
app: remove the hackish "button_press_before_focus" from GimpDisplayShell and simply *always* set the tool to the right state before sending it a button_press. GimpTool's state setting functions are now smart enough to simply ignore setting the same state again. When recieving a FOCUS_IN, skip state setting when the pointer is grabbed, which is a safe indicator for tool interaction going on. This hopefully fixes states for both click-to-focus and focus-follows-mouse *and* fixes the previously warning case where a new image was opened into an already focussed canvas (the warning then happened on button press, and the tool was in an inconsistent state).
2011-04-04 00:42:50 +08:00
* flags, and didn't trigger a FOCUS_IN, but the tool needs
* to be set up correctly regardless, so simply do the
* same things here, it's safe to do them redundantly.
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
*/
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, TRUE,
&image_coords, state);
app: remove the hackish "button_press_before_focus" from GimpDisplayShell and simply *always* set the tool to the right state before sending it a button_press. GimpTool's state setting functions are now smart enough to simply ignore setting the same state again. When recieving a FOCUS_IN, skip state setting when the pointer is grabbed, which is a safe indicator for tool interaction going on. This hopefully fixes states for both click-to-focus and focus-follows-mouse *and* fixes the previously warning case where a new image was opened into an already focussed canvas (the warning then happened on button press, and the tool was in an inconsistent state).
2011-04-04 00:42:50 +08:00
gimp_display_shell_update_cursor (shell, &display_coords,
&image_coords, state, FALSE);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* ignore new mouse events */
if (gimp->busy || shell->scrolling)
return TRUE;
active_tool = tool_manager_get_active (gimp);
switch (bevent->button)
{
case 1:
state |= GDK_BUTTON1_MASK;
event_mask = (GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_RELEASE_MASK);
if (active_tool &&
(! shell->display->config->perfect_mouse ||
(gimp_tool_control_get_motion_mode (active_tool->control) !=
GIMP_MOTION_MODE_EXACT)))
{
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
GdkDisplay *gdk_display = gtk_widget_get_display (canvas);
GimpDeviceManager *manager;
manager = gimp_devices_get_manager (gimp);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* don't request motion hins for XInput devices because
* the wacom driver is known to report crappy hints
* (#6901) --mitch
*/
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
if (gimp_device_manager_get_current_device (manager)->device ==
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
gdk_display_get_core_pointer (gdk_display))
{
event_mask |= GDK_POINTER_MOTION_HINT_MASK;
}
}
if (! gimp_display_shell_pointer_grab (shell, event, event_mask))
return TRUE;
if (! shell->space_pressed && ! shell->space_release_pending)
if (! gimp_display_shell_keyboard_grab (shell, event))
{
gimp_display_shell_pointer_ungrab (shell, event);
return TRUE;
}
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
if (gimp_display_shell_initialize_tool (shell,
&image_coords, state))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: add start_stroke() and finish_stroke() API to GimpMotionBuffer where finish_stroke() is the former flush_event_queue() and start_stroke() is used in BUTTON_PRESS instead of poking into the motion buffer's internals. Also, call finish_stroke() also when the tool is not active, so the event buffer is flushed (the "motion" callback will ignore the events if the tool is not active).
2011-04-18 06:29:32 +08:00
GimpCoords last_motion;
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
/* Use the last evaluated dynamic axes instead of the
* button_press event's ones because the click is
* usually at the same spot as the last motion event
* which would give us bogus dynamics.
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
*/
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
gimp_motion_buffer_begin_stroke (shell->motion_buffer, time,
app: add start_stroke() and finish_stroke() API to GimpMotionBuffer where finish_stroke() is the former flush_event_queue() and start_stroke() is used in BUTTON_PRESS instead of poking into the motion buffer's internals. Also, call finish_stroke() also when the tool is not active, so the event buffer is flushed (the "motion" callback will ignore the events if the tool is not active).
2011-04-18 06:29:32 +08:00
&last_motion);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add start_stroke() and finish_stroke() API to GimpMotionBuffer where finish_stroke() is the former flush_event_queue() and start_stroke() is used in BUTTON_PRESS instead of poking into the motion buffer's internals. Also, call finish_stroke() also when the tool is not active, so the event buffer is flushed (the "motion" callback will ignore the events if the tool is not active).
2011-04-18 06:29:32 +08:00
last_motion.x = image_coords.x;
last_motion.y = image_coords.y;
last_motion.pressure = image_coords.pressure;
last_motion.xtilt = image_coords.xtilt;
last_motion.ytilt = image_coords.ytilt;
last_motion.wheel = image_coords.wheel;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add start_stroke() and finish_stroke() API to GimpMotionBuffer where finish_stroke() is the former flush_event_queue() and start_stroke() is used in BUTTON_PRESS instead of poking into the motion buffer's internals. Also, call finish_stroke() also when the tool is not active, so the event buffer is flushed (the "motion" callback will ignore the events if the tool is not active).
2011-04-18 06:29:32 +08:00
image_coords = last_motion;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
tool_manager_button_press_active (gimp,
&image_coords,
time, state,
GIMP_BUTTON_PRESS_NORMAL,
display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
case 2:
state |= GDK_BUTTON2_MASK;
gimp_display_shell_start_scrolling (shell, bevent->x, bevent->y);
break;
case 3:
{
GimpUIManager *ui_manager;
const gchar *ui_path;
state |= GDK_BUTTON3_MASK;
ui_manager = tool_manager_get_popup_active (gimp,
&image_coords, state,
display,
&ui_path);
if (ui_manager)
{
gimp_ui_manager_ui_popup (ui_manager,
ui_path,
GTK_WIDGET (shell),
NULL, NULL, NULL, NULL);
}
else
{
gimp_ui_manager_ui_popup (shell->popup_manager,
"/dummy-menubar/image-popup",
GTK_WIDGET (shell),
NULL, NULL, NULL, NULL);
}
}
break;
default:
break;
}
return_val = TRUE;
}
break;
case GDK_2BUTTON_PRESS:
{
GdkEventButton *bevent = (GdkEventButton *) event;
GimpTool *active_tool;
if (gimp->busy)
return TRUE;
active_tool = tool_manager_get_active (gimp);
if (bevent->button == 1 &&
active_tool &&
gimp_tool_control_is_active (active_tool->control) &&
gimp_tool_control_get_wants_double_click (active_tool->control))
{
tool_manager_button_press_active (gimp,
&image_coords,
time, state,
GIMP_BUTTON_PRESS_DOUBLE,
display);
}
app: return TRUE after handling double and triple click tool events so we don't redundantly update the cursor again.
2011-03-31 16:21:55 +08:00
/* don't update the cursor again on double click */
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
case GDK_3BUTTON_PRESS:
{
GdkEventButton *bevent = (GdkEventButton *) event;
GimpTool *active_tool;
if (gimp->busy)
return TRUE;
active_tool = tool_manager_get_active (gimp);
if (bevent->button == 1 &&
active_tool &&
gimp_tool_control_is_active (active_tool->control) &&
gimp_tool_control_get_wants_triple_click (active_tool->control))
{
tool_manager_button_press_active (gimp,
&image_coords,
time, state,
GIMP_BUTTON_PRESS_TRIPLE,
display);
}
app: return TRUE after handling double and triple click tool events so we don't redundantly update the cursor again.
2011-03-31 16:21:55 +08:00
/* don't update the cursor again on triple click */
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
case GDK_BUTTON_RELEASE:
{
GdkEventButton *bevent = (GdkEventButton *) event;
GimpTool *active_tool;
gimp_display_shell_autoscroll_stop (shell);
if (gimp->busy)
return TRUE;
active_tool = tool_manager_get_active (gimp);
switch (bevent->button)
{
case 1:
state &= ~GDK_BUTTON1_MASK;
app: ignore button 1 release if we have no pointer grab which is more correct than the previous commit
2011-04-07 04:44:08 +08:00
if (! shell->pointer_grabbed)
app: ignore button releases while another button's action is going on - ignore button 1 release if we are button-2-scrolling - ignore button 2 release if we are not button-2-scrolling
2011-04-07 04:30:44 +08:00
return TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
if (! shell->space_pressed && ! shell->space_release_pending)
gimp_display_shell_keyboard_ungrab (shell, event);
gimp_display_shell_pointer_ungrab (shell, event);
gtk_grab_add (canvas);
if (active_tool &&
(! gimp_image_is_empty (image) ||
gimp_tool_control_get_handle_empty_image (active_tool->control)))
{
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
gimp_motion_buffer_end_stroke (shell->motion_buffer);
app: add start_stroke() and finish_stroke() API to GimpMotionBuffer where finish_stroke() is the former flush_event_queue() and start_stroke() is used in BUTTON_PRESS instead of poking into the motion buffer's internals. Also, call finish_stroke() also when the tool is not active, so the event buffer is flushed (the "motion" callback will ignore the events if the tool is not active).
2011-04-18 06:29:32 +08:00
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
if (gimp_tool_control_is_active (active_tool->control))
{
tool_manager_button_release_active (gimp,
&image_coords,
time, state,
display);
}
}
/* update the tool's modifier state because it didn't get
* key events while BUTTON1 was down
*/
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
if (gtk_widget_has_focus (canvas))
gimp_display_shell_update_focus (shell, TRUE,
&image_coords, state);
else
gimp_display_shell_update_focus (shell, FALSE,
&image_coords, 0);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
gtk_grab_remove (canvas);
if (shell->space_release_pending)
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
gimp_display_shell_space_released (shell, event, &image_coords);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
break;
case 2:
state &= ~GDK_BUTTON2_MASK;
app: ignore button releases while another button's action is going on - ignore button 1 release if we are button-2-scrolling - ignore button 2 release if we are not button-2-scrolling
2011-04-07 04:30:44 +08:00
if (shell->scrolling)
gimp_display_shell_stop_scrolling (shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
break;
case 3:
state &= ~GDK_BUTTON3_MASK;
break;
default:
Add a controller for binding mouse buttons
2011-04-07 05:12:32 +08:00
{
GdkEventButton *bevent = (GdkEventButton *) event;
GimpController *mouse;
mouse = gimp_controllers_get_mouse (gimp);
if (!(shell->scrolling || shell->pointer_grabbed) &&
mouse && gimp_controller_mouse_button (GIMP_CONTROLLER_MOUSE (mouse),
bevent))
return TRUE;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
break;
}
return_val = TRUE;
}
break;
case GDK_SCROLL:
{
GdkEventScroll *sevent = (GdkEventScroll *) event;
GimpController *wheel;
wheel = gimp_controllers_get_wheel (gimp);
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
if (! wheel ||
! gimp_controller_wheel_scroll (GIMP_CONTROLLER_WHEEL (wheel),
sevent))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
GdkScrollDirection direction = sevent->direction;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
if (state & GDK_CONTROL_MASK)
{
switch (direction)
{
case GDK_SCROLL_UP:
gimp_display_shell_scale (shell,
GIMP_ZOOM_IN,
0.0,
GIMP_ZOOM_FOCUS_BEST_GUESS);
break;
case GDK_SCROLL_DOWN:
gimp_display_shell_scale (shell,
GIMP_ZOOM_OUT,
0.0,
GIMP_ZOOM_FOCUS_BEST_GUESS);
break;
default:
break;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
else
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
GtkAdjustment *adj = NULL;
gdouble value;
if (state & GDK_SHIFT_MASK)
switch (direction)
{
case GDK_SCROLL_UP: direction = GDK_SCROLL_LEFT; break;
case GDK_SCROLL_DOWN: direction = GDK_SCROLL_RIGHT; break;
case GDK_SCROLL_LEFT: direction = GDK_SCROLL_UP; break;
case GDK_SCROLL_RIGHT: direction = GDK_SCROLL_DOWN; break;
}
switch (direction)
{
case GDK_SCROLL_LEFT:
case GDK_SCROLL_RIGHT:
adj = shell->hsbdata;
break;
case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN:
adj = shell->vsbdata;
break;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: update the tool's state after the wheel controller has handled the event
2011-04-07 04:50:20 +08:00
value = (gtk_adjustment_get_value (adj) +
((direction == GDK_SCROLL_UP ||
direction == GDK_SCROLL_LEFT) ?
-gtk_adjustment_get_page_increment (adj) / 2 :
gtk_adjustment_get_page_increment (adj) / 2));
value = CLAMP (value,
gtk_adjustment_get_lower (adj),
gtk_adjustment_get_upper (adj) -
gtk_adjustment_get_page_size (adj));
gtk_adjustment_set_value (adj, value);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
}
gimp_display_shell_untransform_event_coords (shell,
&display_coords,
&image_coords,
&update_sw_cursor);
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
return_val = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
GdkEvent *compressed_motion = NULL;
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
GimpMotionMode motion_mode = GIMP_MOTION_MODE_EXACT;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
GimpTool *active_tool;
if (gimp->busy)
return TRUE;
active_tool = tool_manager_get_active (gimp);
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
if (active_tool)
motion_mode = gimp_tool_control_get_motion_mode (active_tool->control);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
if (shell->scrolling ||
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
motion_mode == GIMP_MOTION_MODE_COMPRESS)
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
compressed_motion = gimp_display_shell_compress_motion (shell);
if (compressed_motion && ! shell->scrolling)
{
gimp_display_shell_get_event_coords (shell,
compressed_motion,
&display_coords,
&state, &time);
gimp_display_shell_untransform_event_coords (shell,
&display_coords,
&image_coords,
NULL);
}
}
/* Ask for more motion events in case the event was a hint */
gdk_event_request_motions (mevent);
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
/* call proximity_in() here because the pointer might already
* be in proximity when the canvas starts to receive events,
* like when a new image has been created into an empty
* display
*/
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
gimp_display_shell_proximity_in (shell);
update_sw_cursor = TRUE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
if (shell->scrolling)
{
const gint x = (compressed_motion
? ((GdkEventMotion *) compressed_motion)->x
: mevent->x);
const gint y = (compressed_motion
? ((GdkEventMotion *) compressed_motion)->y
: mevent->y);
gimp_display_shell_scroll (shell,
(shell->scroll_start_x - x -
shell->offset_x),
(shell->scroll_start_y - y -
shell->offset_y));
}
else if (state & GDK_BUTTON1_MASK)
{
if (active_tool &&
gimp_tool_control_is_active (active_tool->control) &&
(! gimp_image_is_empty (image) ||
gimp_tool_control_get_handle_empty_image (active_tool->control)))
{
GdkTimeCoord **history_events;
gint n_history_events;
app: add gimp_motion_buffer_get_last_motion_time() and use it The last poking into the buffer is gone now.
2011-04-18 19:13:51 +08:00
guint32 last_motion_time;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* if the first mouse button is down, check for automatic
* scrolling...
*/
if ((mevent->x < 0 ||
mevent->y < 0 ||
mevent->x > shell->disp_width ||
mevent->y > shell->disp_height) &&
! gimp_tool_control_get_scroll_lock (active_tool->control))
{
gimp_display_shell_autoscroll_start (shell, state, mevent);
}
app: add gimp_motion_buffer_get_last_motion_time() and use it The last poking into the buffer is gone now.
2011-04-18 19:13:51 +08:00
/* gdk_device_get_history() has several quirks. First
* is that events with borderline timestamps at both
* ends are included. Because of that we need to add 1
* to lower border. The second is due to poor X event
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
* resolution. We need to do -1 to ensure that the
* amount of events between timestamps is final or
* risk loosing some.
*/
app: add gimp_motion_buffer_get_last_motion_time() and use it The last poking into the buffer is gone now.
2011-04-18 19:13:51 +08:00
last_motion_time =
gimp_motion_buffer_get_last_motion_time (shell->motion_buffer);
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
if (motion_mode == GIMP_MOTION_MODE_EXACT &&
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
shell->display->config->use_event_history &&
gdk_device_get_history (mevent->device, mevent->window,
app: add gimp_motion_buffer_get_last_motion_time() and use it The last poking into the buffer is gone now.
2011-04-18 19:13:51 +08:00
last_motion_time + 1,
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
mevent->time - 1,
&history_events,
&n_history_events))
{
GimpDeviceInfo *device;
gint i;
device = gimp_device_info_get_by_device (mevent->device);
for (i = 0; i < n_history_events; i++)
{
gimp_device_info_get_time_coords (device,
history_events[i],
&display_coords);
gimp_display_shell_untransform_event_coords (shell,
&display_coords,
&image_coords,
NULL);
/* Early removal of useless events saves CPU time.
*/
app: rename gimp_motion_buffer_eval_event() to motion_event() because it's feeding it motion events.
2011-04-18 07:09:57 +08:00
if (gimp_motion_buffer_motion_event (shell->motion_buffer,
&image_coords,
history_events[i]->time,
shell->scale_x,
shell->scale_y,
TRUE))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: rename process_stroke() and process_hover() to request_foo() Because that's what we are doing by calling the functions: requesting the emission of "stroke" and "hover" signals.
2011-04-18 17:31:38 +08:00
gimp_motion_buffer_request_stroke (shell->motion_buffer,
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
state,
history_events[i]->time);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
}
gdk_device_free_history (history_events, n_history_events);
}
else
{
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
gboolean event_fill = (motion_mode == GIMP_MOTION_MODE_EXACT);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* Early removal of useless events saves CPU time.
*/
app: rename gimp_motion_buffer_eval_event() to motion_event() because it's feeding it motion events.
2011-04-18 07:09:57 +08:00
if (gimp_motion_buffer_motion_event (shell->motion_buffer,
&image_coords,
time,
shell->scale_x,
shell->scale_y,
event_fill))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: rename process_stroke() and process_hover() to request_foo() Because that's what we are doing by calling the functions: requesting the emission of "stroke" and "hover" signals.
2011-04-18 17:31:38 +08:00
gimp_motion_buffer_request_stroke (shell->motion_buffer,
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
state,
time);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
}
}
}
if (! (state &
(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)))
{
/* Early removal of useless events saves CPU time.
app: s/gdouble inertia_factor/gboolean event_fill/ in eval_event() Also remove "gdouble max_coord_smooth" from GimpTool and simply use the existing motion mode for deciding whether or not to fill in events.
2011-04-18 01:59:31 +08:00
* Pass event_fill = FALSE since we are only hovering.
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
*/
app: rename gimp_motion_buffer_eval_event() to motion_event() because it's feeding it motion events.
2011-04-18 07:09:57 +08:00
if (gimp_motion_buffer_motion_event (shell->motion_buffer,
&image_coords,
time,
shell->scale_x,
shell->scale_y,
FALSE))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: rename process_stroke() and process_hover() to request_foo() Because that's what we are doing by calling the functions: requesting the emission of "stroke" and "hover" signals.
2011-04-18 17:31:38 +08:00
gimp_motion_buffer_request_hover (shell->motion_buffer,
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
state,
shell->proximity);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
}
return_val = TRUE;
}
break;
case GDK_KEY_PRESS:
{
GdkEventKey *kevent = (GdkEventKey *) event;
GimpTool *active_tool;
active_tool = tool_manager_get_active (gimp);
if (state & GDK_BUTTON1_MASK)
{
switch (kevent->keyval)
{
case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:
case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:
case GDK_KEY_Control_L: case GDK_KEY_Control_R:
{
GdkModifierType key;
key = gimp_display_shell_key_to_state (kevent->keyval);
state |= key;
if (active_tool &&
gimp_tool_control_is_active (active_tool->control) &&
! gimp_image_is_empty (image))
{
tool_manager_active_modifier_state_active (gimp, state,
display);
}
}
break;
}
}
else
{
tool_manager_focus_display_active (gimp, display);
if (gimp_tool_control_get_wants_all_key_events (active_tool->control))
{
if (tool_manager_key_press_active (gimp, kevent, display))
{
/* FIXME: need to do some of the stuff below, like
* calling oper_update()
*/
return TRUE;
}
}
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
case GDK_KEY_BackSpace:
case GDK_KEY_Escape:
case GDK_KEY_Left:
case GDK_KEY_Right:
case GDK_KEY_Up:
case GDK_KEY_Down:
if (gimp_image_is_empty (image) ||
! tool_manager_key_press_active (gimp,
kevent,
display))
{
GimpController *keyboard = gimp_controllers_get_keyboard (gimp);
if (keyboard)
gimp_controller_keyboard_key_press (GIMP_CONTROLLER_KEYBOARD (keyboard),
kevent);
}
return_val = TRUE;
break;
case GDK_KEY_space:
case GDK_KEY_KP_Space:
gimp_display_shell_space_pressed (shell, event);
return_val = TRUE;
break;
case GDK_KEY_Tab:
case GDK_KEY_ISO_Left_Tab:
if (state & GDK_CONTROL_MASK)
{
if (! gimp_image_is_empty (image))
{
if (kevent->keyval == GDK_KEY_Tab)
gimp_display_shell_layer_select_init (shell,
1, kevent->time);
else
gimp_display_shell_layer_select_init (shell,
-1, kevent->time);
}
}
else
{
gimp_display_shell_toggle_hide_docks (shell);
}
return_val = TRUE;
break;
/* Update the state based on modifiers being pressed */
case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:
case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:
case GDK_KEY_Control_L: case GDK_KEY_Control_R:
{
GdkModifierType key;
key = gimp_display_shell_key_to_state (kevent->keyval);
state |= key;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! gimp_image_is_empty (image))
tool_manager_modifier_state_active (gimp, state, display);
}
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
}
break;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GDK_KEY_RELEASE:
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
GdkEventKey *kevent = (GdkEventKey *) event;
GimpTool *active_tool;
active_tool = tool_manager_get_active (gimp);
if (state & GDK_BUTTON1_MASK)
{
switch (kevent->keyval)
{
case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:
case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:
case GDK_KEY_Control_L: case GDK_KEY_Control_R:
{
GdkModifierType key;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
key = gimp_display_shell_key_to_state (kevent->keyval);
state &= ~key;
if (active_tool &&
gimp_tool_control_is_active (active_tool->control) &&
! gimp_image_is_empty (image))
{
tool_manager_active_modifier_state_active (gimp, state,
display);
}
}
break;
}
}
else
{
tool_manager_focus_display_active (gimp, display);
if (gimp_tool_control_get_wants_all_key_events (active_tool->control))
{
if (tool_manager_key_release_active (gimp, kevent, display))
{
/* FIXME: need to do some of the stuff below, like
* calling oper_update()
*/
return TRUE;
}
}
switch (kevent->keyval)
{
case GDK_KEY_space:
case GDK_KEY_KP_Space:
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
gimp_display_shell_space_released (shell, event, NULL);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
return_val = TRUE;
break;
/* Update the state based on modifiers being pressed */
case GDK_KEY_Alt_L: case GDK_KEY_Alt_R:
case GDK_KEY_Shift_L: case GDK_KEY_Shift_R:
case GDK_KEY_Control_L: case GDK_KEY_Control_R:
{
GdkModifierType key;
key = gimp_display_shell_key_to_state (kevent->keyval);
state &= ~key;
/* For all modifier keys: call the tools
* modifier_state *and* oper_update method so tools
* can choose if they are interested in the press
* itself or only in the resulting state
*/
if (! gimp_image_is_empty (image))
tool_manager_modifier_state_active (gimp, state, display);
}
break;
}
tool_manager_oper_update_active (gimp,
&image_coords, state,
shell->proximity,
display);
}
}
break;
default:
break;
}
/* if we reached this point in gimp_busy mode, return now */
if (gimp->busy)
return return_val;
/* cursor update */
gimp_display_shell_update_cursor (shell, &display_coords, &image_coords,
state, update_sw_cursor);
return return_val;
}
app: move process_event_queue() and flush_event_queue() to GimpMotionBuffer and emit the buffer's "motion" signal when a motion is supposed to happen. In GimpDisplayShell, connect to GimpMotionBuffer::motion() and call the tool.
2011-04-18 03:46:29 +08:00
void
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
gimp_display_shell_buffer_stroke (GimpMotionBuffer *buffer,
app: move process_event_queue() and flush_event_queue() to GimpMotionBuffer and emit the buffer's "motion" signal when a motion is supposed to happen. In GimpDisplayShell, connect to GimpMotionBuffer::motion() and call the tool.
2011-04-18 03:46:29 +08:00
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplayShell *shell)
{
GimpDisplay *display = shell->display;
Gimp *gimp = gimp_display_get_gimp (display);
GimpTool *active_tool;
active_tool = tool_manager_get_active (gimp);
if (active_tool &&
gimp_tool_control_is_active (active_tool->control))
{
tool_manager_motion_active (gimp,
coords, time, state,
display);
}
}
app: GimpMotionBuffer API cleanup and refactoring - start_stroke()/finih_stroke() -> begin_stroke()/end_stroke() - process_event_queue() -> process_stroke() - GimpMotionBuffer::motion() -> GimpMotionBuffer::stroke() - add GimpMotionBuffer::hover() and process_hover() - remove push_event_history() and pop_event_queue() from API The thing works like this: - Motion events are continuously fed into the buffer using motion_event() - begin_stroke()/end_stroke() correspond to BUTTON_PRESS/BUTTON_RELEASE, the period between them is a "stroke" - If motion_event() returns TRUE, we request "stroke" signals by calling process_stroke() and "hover" signals by calling process_hover()
2011-04-18 17:08:24 +08:00
void
gimp_display_shell_buffer_hover (GimpMotionBuffer *buffer,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplayShell *shell)
{
GimpDisplay *display = shell->display;
Gimp *gimp = gimp_display_get_gimp (display);
GimpTool *active_tool;
active_tool = tool_manager_get_active (gimp);
if (active_tool &&
! gimp_tool_control_is_active (active_tool->control))
{
tool_manager_oper_update_active (gimp,
coords, state, proximity,
display);
}
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static gboolean
gimp_display_shell_ruler_button_press (GtkWidget *widget,
GdkEventButton *event,
GimpDisplayShell *shell,
gboolean horizontal)
{
GimpDisplay *display = shell->display;
if (display->gimp->busy)
return TRUE;
if (! gimp_display_get_image (display))
return TRUE;
if (event->type == GDK_BUTTON_PRESS && event->button == 1)
{
GimpTool *active_tool;
gboolean sample_point;
active_tool = tool_manager_get_active (display->gimp);
sample_point = (event->state & GDK_CONTROL_MASK);
if (! ((sample_point && (GIMP_IS_COLOR_TOOL (active_tool) &&
! GIMP_IS_IMAGE_MAP_TOOL (active_tool) &&
! (GIMP_IS_PAINT_TOOL (active_tool) &&
! GIMP_PAINT_TOOL (active_tool)->pick_colors)))
||
(! sample_point && GIMP_IS_MOVE_TOOL (active_tool))))
{
GimpToolInfo *tool_info;
tool_info = gimp_get_tool_info (display->gimp,
sample_point ?
"gimp-color-picker-tool" :
"gimp-move-tool");
if (tool_info)
app: remove the hackish "button_press_before_focus" from GimpDisplayShell and simply *always* set the tool to the right state before sending it a button_press. GimpTool's state setting functions are now smart enough to simply ignore setting the same state again. When recieving a FOCUS_IN, skip state setting when the pointer is grabbed, which is a safe indicator for tool interaction going on. This hopefully fixes states for both click-to-focus and focus-follows-mouse *and* fixes the previously warning case where a new image was opened into an already focussed canvas (the warning then happened on button press, and the tool was in an inconsistent state).
2011-04-04 00:42:50 +08:00
gimp_context_set_tool (gimp_get_user_context (display->gimp),
tool_info);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
active_tool = tool_manager_get_active (display->gimp);
if (active_tool)
{
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, TRUE,
NULL, event->state);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (gimp_display_shell_pointer_grab (shell,
(GdkEvent *) event,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK))
{
if (gimp_display_shell_keyboard_grab (shell,
(GdkEvent *) event))
{
if (sample_point)
gimp_color_tool_start_sample_point (active_tool, display);
else if (horizontal)
gimp_move_tool_start_hguide (active_tool, display);
else
gimp_move_tool_start_vguide (active_tool, display);
return TRUE;
}
else
{
gimp_display_shell_pointer_ungrab (shell,
(GdkEvent *) event);
}
}
}
}
return FALSE;
}
gboolean
gimp_display_shell_hruler_button_press (GtkWidget *widget,
GdkEventButton *event,
GimpDisplayShell *shell)
{
return gimp_display_shell_ruler_button_press (widget, event, shell, TRUE);
}
gboolean
gimp_display_shell_vruler_button_press (GtkWidget *widget,
GdkEventButton *event,
GimpDisplayShell *shell)
{
return gimp_display_shell_ruler_button_press (widget, event, shell, FALSE);
}
/* private functions */
static GdkModifierType
gimp_display_shell_key_to_state (gint key)
{
switch (key)
{
case GDK_KEY_Alt_L:
case GDK_KEY_Alt_R:
return GDK_MOD1_MASK;
case GDK_KEY_Shift_L:
case GDK_KEY_Shift_R:
return GDK_SHIFT_MASK;
case GDK_KEY_Control_L:
case GDK_KEY_Control_R:
return GDK_CONTROL_MASK;
default:
return 0;
}
}
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
static void
gimp_display_shell_proximity_in (GimpDisplayShell *shell)
{
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
if (! shell->proximity)
{
shell->proximity = TRUE;
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
gimp_display_shell_check_device_cursor (shell);
}
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
}
static void
gimp_display_shell_proximity_out (GimpDisplayShell *shell)
{
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
if (shell->proximity)
{
shell->proximity = FALSE;
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
app: redo the last commit and call proximity_in() at all logical places Keep the comment at the place where calling it isn't immediately obvious, and add checks to proximity_in() and out() so they bail out when the proximity state is already set correctly.
2011-02-27 19:16:51 +08:00
gimp_display_shell_clear_software_cursor (shell);
}
app: add utility functions proximity_in() and proximity_out() and use them instead of manually setting proximity. Also add comments about why we call the proximity functions where we call them (instead of calling them where it seems more logical).
2011-02-27 19:08:09 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_check_device_cursor (GimpDisplayShell *shell)
{
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
GimpDeviceManager *manager;
GimpDeviceInfo *current_device;
manager = gimp_devices_get_manager (shell->display->gimp);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
current_device = gimp_device_manager_get_current_device (manager);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->draw_cursor = ! gimp_device_info_has_cursor (current_device);
}
static void
gimp_display_shell_toggle_hide_docks (GimpDisplayShell *shell)
{
GimpImageWindow *window = gimp_display_shell_get_window (shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (window)
gimp_ui_manager_activate_action (gimp_image_window_get_ui_manager (window),
"windows",
"windows-hide-docks");
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_start_scrolling (GimpDisplayShell *shell,
gint x,
gint y)
{
g_return_if_fail (! shell->scrolling);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->scrolling = TRUE;
shell->scroll_start_x = x + shell->offset_x;
shell->scroll_start_y = y + shell->offset_y;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_set_override_cursor (shell, GDK_FLEUR);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gtk_grab_add (shell->canvas);
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_stop_scrolling (GimpDisplayShell *shell)
{
g_return_if_fail (shell->scrolling);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->scrolling = FALSE;
shell->scroll_start_x = 0;
shell->scroll_start_y = 0;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_unset_override_cursor (shell);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gtk_grab_remove (shell->canvas);
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_space_pressed (GimpDisplayShell *shell,
GdkEvent *event)
{
Gimp *gimp = gimp_display_get_gimp (shell->display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (shell->space_pressed)
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! gimp_display_shell_keyboard_grab (shell, event))
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
switch (shell->display->config->space_bar_action)
{
case GIMP_SPACE_BAR_ACTION_NONE:
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GIMP_SPACE_BAR_ACTION_PAN:
{
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
GimpDeviceManager *manager;
GimpDeviceInfo *current_device;
GimpCoords coords;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! gimp_display_shell_pointer_grab (shell, event,
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK))
{
gimp_display_shell_keyboard_ungrab (shell, event);
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
manager = gimp_devices_get_manager (gimp);
current_device = gimp_device_manager_get_current_device (manager);
gimp_device_info_get_device_coords (current_device,
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gtk_widget_get_window (shell->canvas),
&coords);
gimp_display_shell_start_scrolling (shell, coords.x, coords.y);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GIMP_SPACE_BAR_ACTION_MOVE:
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
GimpTool *active_tool = tool_manager_get_active (gimp);
GdkModifierType state;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! active_tool || GIMP_IS_MOVE_TOOL (active_tool))
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->space_shaded_tool =
gimp_object_get_name (active_tool->tool_info);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_context_set_tool (gimp_get_user_context (gimp),
gimp_get_tool_info (gimp, "gimp-move-tool"));
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gdk_event_get_state (event, &state);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, TRUE,
NULL, state);
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
break;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->space_pressed = TRUE;
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_space_released (GimpDisplayShell *shell,
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
GdkEvent *event,
const GimpCoords *image_coords)
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
{
Gimp *gimp = gimp_display_get_gimp (shell->display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! shell->space_pressed && ! shell->space_release_pending)
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
switch (shell->display->config->space_bar_action)
{
case GIMP_SPACE_BAR_ACTION_NONE:
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GIMP_SPACE_BAR_ACTION_PAN:
gimp_display_shell_stop_scrolling (shell);
gimp_display_shell_pointer_ungrab (shell, event);
break;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
case GIMP_SPACE_BAR_ACTION_MOVE:
{
gimp_context_set_tool (gimp_get_user_context (gimp),
gimp_get_tool_info (gimp,
shell->space_shaded_tool));
shell->space_shaded_tool = NULL;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
if (gtk_widget_has_focus (shell->canvas))
{
GdkModifierType state;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: completely ignore focus change events while we have a grab in order to be safe against whatever windowing system / event manager depending event order. Also properly update the tool's state after a button reelease, and after a space release.
2011-04-07 03:35:29 +08:00
gdk_event_get_state (event, &state);
gimp_display_shell_update_focus (shell, TRUE,
image_coords, state);
}
else
{
gimp_display_shell_update_focus (shell, FALSE,
image_coords, 0);
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
break;
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_keyboard_ungrab (shell, event);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
shell->space_pressed = FALSE;
shell->space_release_pending = FALSE;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_update_focus (GimpDisplayShell *shell,
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gboolean focus_in,
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
const GimpCoords *image_coords,
GdkModifierType state)
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
Gimp *gimp = gimp_display_get_gimp (shell->display);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
if (focus_in)
{
tool_manager_focus_display_active (gimp, shell->display);
tool_manager_modifier_state_active (gimp, state, shell->display);
}
else
{
tool_manager_focus_display_active (gimp, NULL);
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (image_coords)
tool_manager_oper_update_active (gimp,
image_coords, state,
shell->proximity,
shell->display);
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_update_cursor (GimpDisplayShell *shell,
const GimpCoords *display_coords,
const GimpCoords *image_coords,
GdkModifierType state,
gboolean update_software_cursor)
{
GimpDisplay *display = shell->display;
Gimp *gimp = gimp_display_get_gimp (display);
GimpImage *image = gimp_display_get_image (display);
GimpTool *active_tool;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (! shell->display->config->cursor_updating)
return;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
active_tool = tool_manager_get_active (gimp);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (active_tool)
{
if ((! gimp_image_is_empty (image) ||
gimp_tool_control_get_handle_empty_image (active_tool->control)) &&
! (state & (GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK)))
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
tool_manager_cursor_update_active (gimp,
image_coords, state,
display);
}
else if (gimp_image_is_empty (image) &&
! gimp_tool_control_get_handle_empty_image (active_tool->control))
{
gimp_display_shell_set_cursor (shell,
GIMP_CURSOR_MOUSE,
gimp_tool_control_get_tool_cursor (active_tool->control),
GIMP_CURSOR_MODIFIER_BAD);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
}
else
{
gimp_display_shell_set_cursor (shell,
GIMP_CURSOR_MOUSE,
GIMP_TOOL_CURSOR_NONE,
GIMP_CURSOR_MODIFIER_BAD);
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (update_software_cursor)
{
GimpCursorPrecision precision = GIMP_CURSOR_PRECISION_PIXEL_CENTER;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
if (active_tool)
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
precision = gimp_tool_control_get_precision (active_tool->control);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gimp_display_shell_update_software_cursor (shell,
precision,
(gint) display_coords->x,
(gint) display_coords->y,
image_coords->x,
image_coords->y);
}
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
static gboolean
gimp_display_shell_initialize_tool (GimpDisplayShell *shell,
const GimpCoords *image_coords,
GdkModifierType state)
{
GimpDisplay *display = shell->display;
GimpImage *image = gimp_display_get_image (display);
Gimp *gimp = gimp_display_get_gimp (display);
gboolean initialized = FALSE;
GimpTool *active_tool;
active_tool = tool_manager_get_active (gimp);
if (active_tool &&
(! gimp_image_is_empty (image) ||
gimp_tool_control_get_handle_empty_image (active_tool->control)))
{
initialized = TRUE;
/* initialize the current tool if it has no drawable */
if (! active_tool->drawable)
{
initialized = tool_manager_initialize_active (gimp, display);
}
else if ((active_tool->drawable !=
gimp_image_get_active_drawable (image)) &&
! gimp_tool_control_get_preserve (active_tool->control))
{
/* create a new one, deleting the current */
gimp_context_tool_changed (gimp_get_user_context (gimp));
/* make sure the newly created tool has the right state */
app: add "gboolean focus_in" to gimp_display_shell_update_focus() and use it to update the tool's state also when the canvas gets a FOCUS_OUT.
2011-04-04 01:01:13 +08:00
gimp_display_shell_update_focus (shell, TRUE, image_coords, state);
app: add gimp_display_shell_initialize_tool() in tool-events.c so another big block of logic is gone from "the huge function".
2011-04-04 00:27:03 +08:00
initialized = tool_manager_initialize_active (gimp, display);
}
}
return initialized;
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_get_event_coords (GimpDisplayShell *shell,
GdkEvent *event,
GimpCoords *display_coords,
GdkModifierType *state,
guint32 *time)
{
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
Gimp *gimp = gimp_display_get_gimp (shell->display);
GimpDeviceManager *manager;
GimpDeviceInfo *current_device;
manager = gimp_devices_get_manager (gimp);
current_device = gimp_device_manager_get_current_device (manager);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
gimp_device_info_get_event_coords (current_device,
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gtk_widget_get_window (shell->canvas),
event,
display_coords);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: GimpDeviceManager refactoring part two - change gimp_devices_get_list() to gimp_devices_get_manager() - remove gimp_devices_get_current() - let GimpDeviceStatus connect to the manager's "notify::current-device" directly and remove device status updating code from gui.c - cleanup in gimpdevices.c
2011-02-28 21:37:00 +08:00
gimp_device_info_get_event_state (current_device,
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
gtk_widget_get_window (shell->canvas),
event,
state);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
*time = gdk_event_get_time (event);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
}
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
static void
gimp_display_shell_untransform_event_coords (GimpDisplayShell *shell,
const GimpCoords *display_coords,
GimpCoords *image_coords,
gboolean *update_software_cursor)
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
{
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
Gimp *gimp = gimp_display_get_gimp (shell->display);
GimpTool *active_tool;
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
/* GimpCoords passed to tools are ALWAYS in image coordinates */
gimp_display_shell_untransform_coords (shell,
display_coords,
image_coords);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
active_tool = tool_manager_get_active (gimp);
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
app: clean up static functions in the new tool-events.c file
2011-02-23 13:22:24 +08:00
if (active_tool && gimp_tool_control_get_snap_to (active_tool->control))
{
gint x, y, width, height;
gimp_tool_control_get_snap_offsets (active_tool->control,
&x, &y, &width, &height);
if (gimp_display_shell_snap_coords (shell,
image_coords,
x, y, width, height))
{
if (update_software_cursor)
*update_software_cursor = TRUE;
}
}
}
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
/* gimp_display_shell_compress_motion:
*
* This function walks the whole GDK event queue seeking motion events
* corresponding to the widget 'widget'. If it finds any it will
* remove them from the queue, and return the most recent motion event.
* Otherwise it will return NULL.
*
* The gimp_display_shell_compress_motion function source may be re-used under
* the XFree86-style license. <adam@gimp.org>
*/
static GdkEvent *
gimp_display_shell_compress_motion (GimpDisplayShell *shell)
{
GList *requeued_events = NULL;
const GList *list;
GdkEvent *last_motion = NULL;
/* Move the entire GDK event queue to a private list, filtering
* out any motion events for the desired widget.
*/
while (gdk_events_pending ())
{
GdkEvent *event = gdk_event_get ();
if (!event)
{
/* Do nothing */
}
else if ((gtk_get_event_widget (event) == shell->canvas) &&
(event->any.type == GDK_MOTION_NOTIFY))
{
if (last_motion)
gdk_event_free (last_motion);
last_motion = event;
}
else
{
requeued_events = g_list_prepend (requeued_events, event);
}
}
/* Replay the remains of our private event list back into the
* event queue in order.
*/
requeued_events = g_list_reverse (requeued_events);
for (list = requeued_events; list; list = g_list_next (list))
{
GdkEvent *event = list->data;
gdk_event_put (event);
gdk_event_free (event);
}
g_list_free (requeued_events);
return last_motion;
}