brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ba8d682c09
mutter/clutter/gdk/clutter-event-gdk.c
Emmanuele Bassi 8eb71af23d gdk/events: Clean up the event handling code 
We need debugging notes, to see what's happening when handling events.

We need to queue a (clipped) redraw when receiving a GDK_EXPOSE event.

We need to check the device (both master and source) of the event using
the GdkEvent API, and pass them to the ClutterEvent using the
corresponding Clutter API.
2011-11-03 13:45:20 +00:00

347 lines
11 KiB
C
Raw Blame History

/* Clutter.
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
* Copyright (C) 2009, 2010 Intel Corp.
* 2011 Giovanni Campagna <scampa.giovanni@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*
*
* Authored by:
* Matthew Allum <mallum@openedhand.com>
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
#include "config.h"
#include "clutter-gdk.h"
#include "clutter-backend-gdk.h"
#include "clutter-device-manager-gdk.h"
#include "clutter-actor-private.h"
#include "clutter-backend-private.h"
#include "clutter-debug.h"
#include "clutter-event-private.h"
#include "clutter-main.h"
#include "clutter-paint-volume-private.h"
#include "clutter-stage-private.h"
#include <string.h>
#include <glib.h>
static void
gdk_event_handler (GdkEvent *event,
gpointer user_data)
{
clutter_gdk_handle_event (event);
}
void
_clutter_backend_gdk_events_init (ClutterBackend *backend)
{
gdk_event_handler_set (gdk_event_handler, NULL, NULL);
CLUTTER_NOTE (EVENT, "GDK event handler set");
}
void
_clutter_backend_gdk_events_uninit (ClutterBackend *backend)
{
gdk_event_handler_set (NULL, NULL, NULL);
}
/**
* clutter_gdk_handle_event:
* @event: a #GdkEvent
*
* This function processes a single GDK event; it can be used to hook
* into external event processing
*
* Return value: #GdkFilterReturn. %GDK_FILTER_REMOVE indicates that
* Clutter has internally handled the event and the caller should do
* no further processing. %GDK_FILTER_CONTINUE indicates that Clutter
* is either not interested in the event, or has used the event to
* update internal state without taking any exclusive action.
* %GDK_FILTER_TRANSLATE will not occur.
*
*/
GdkFilterReturn
clutter_gdk_handle_event (GdkEvent *gdk_event)
{
ClutterDeviceManager *device_manager;
ClutterBackendGdk *backend_gdk;
ClutterBackend *backend;
ClutterStage *stage = NULL;
ClutterEvent *event = NULL;
gint spin = 0;
GdkFilterReturn result = GDK_FILTER_CONTINUE;
ClutterInputDevice *device, *source_device;
GdkDevice *gdk_device;
backend = clutter_get_default_backend ();
if (!CLUTTER_IS_BACKEND_GDK (backend))
return GDK_FILTER_CONTINUE;
if (gdk_event->any.window == NULL)
return GDK_FILTER_CONTINUE;
backend_gdk = CLUTTER_BACKEND_GDK (backend);
stage = clutter_gdk_get_stage_from_window (gdk_event->any.window);
device_manager = clutter_device_manager_get_default ();
gdk_device = gdk_event_get_device (gdk_event);
if (gdk_device != NULL)
device = _clutter_device_manager_gdk_lookup_device (device_manager,
gdk_device);
else
device = NULL;
gdk_device = gdk_event_get_source_device (gdk_event);
if (gdk_device != NULL)
source_device = _clutter_device_manager_gdk_lookup_device (device_manager,
gdk_device);
else
source_device = NULL;
if (stage == NULL)
return GDK_FILTER_CONTINUE;
clutter_threads_enter ();
switch (gdk_event->type)
{
case GDK_DELETE:
event = clutter_event_new (CLUTTER_DELETE);
break;
case GDK_DESTROY:
event = clutter_event_new (CLUTTER_DESTROY_NOTIFY);
break;
case GDK_EXPOSE:
{
ClutterPaintVolume clip;
ClutterVertex origin;
CLUTTER_NOTE (EVENT, "Expose for stage '%s' [%p] { %d, %d - %d x %d }",
_clutter_actor_get_debug_name (CLUTTER_ACTOR (stage)),
stage,
gdk_event->expose.area.x,
gdk_event->expose.area.y,
gdk_event->expose.area.width,
gdk_event->expose.area.height);
origin.x = gdk_event->expose.area.x;
origin.y = gdk_event->expose.area.y;
origin.z = 0;
_clutter_paint_volume_init_static (&clip, CLUTTER_ACTOR (stage));
clutter_paint_volume_set_origin (&clip, &origin);
clutter_paint_volume_set_width (&clip, gdk_event->expose.area.width);
clutter_paint_volume_set_height (&clip, gdk_event->expose.area.height);
_clutter_actor_queue_redraw_with_clip (CLUTTER_ACTOR (stage), 0, &clip);
clutter_paint_volume_free (&clip);
}
break;
case GDK_DAMAGE:
/* This is handled by cogl */
break;
case GDK_MOTION_NOTIFY:
event = clutter_event_new (CLUTTER_MOTION);
event->motion.time = gdk_event->motion.time;
event->motion.x = gdk_event->motion.x;
event->motion.y = gdk_event->motion.y;
event->motion.axes = NULL;
/* It's all X in the end, right? */
event->motion.modifier_state = gdk_event->motion.state;
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
CLUTTER_NOTE (EVENT, "Motion notifiy [%.2f, %.2f]",
event->motion.x,
event->motion.y);
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
event = clutter_event_new (gdk_event->type == GDK_BUTTON_PRESS ?
CLUTTER_BUTTON_PRESS :
CLUTTER_BUTTON_RELEASE);
event->button.time = gdk_event->button.time;
event->button.x = gdk_event->button.x;
event->button.y = gdk_event->button.y;
event->button.axes = NULL;
event->button.modifier_state = gdk_event->button.state;
event->button.button = gdk_event->button.button;
event->button.click_count = 1;
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
CLUTTER_NOTE (EVENT, "Button %d %s [%.2f, %.2f]",
event->button.button,
event->type == CLUTTER_BUTTON_PRESS ? "press" : "release",
event->button.x,
event->button.y);
break;
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
/* these are handled by clutter-main.c updating click_count */
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
event = clutter_event_new (gdk_event->type == GDK_KEY_PRESS ?
CLUTTER_KEY_PRESS :
CLUTTER_KEY_RELEASE);
event->key.time = gdk_event->key.time;
event->key.modifier_state = gdk_event->key.state;
event->key.keyval = gdk_event->key.keyval;
event->key.hardware_keycode = gdk_event->key.hardware_keycode;
event->key.unicode_value = g_utf8_get_char (gdk_event->key.string);
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
CLUTTER_NOTE (EVENT, "Key %d %s",
event->key.keyval,
event->type == CLUTTER_KEY_PRESS ? "press" : "release");
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
event = clutter_event_new (gdk_event->type == GDK_ENTER_NOTIFY ?
CLUTTER_ENTER :
CLUTTER_LEAVE);
event->crossing.source = CLUTTER_ACTOR (stage);
event->crossing.time = gdk_event_get_time (gdk_event);
event->crossing.x = gdk_event->crossing.x;
event->crossing.y = gdk_event->crossing.y;
/* XXX: no better fallback here? */
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
if (gdk_event->type == GDK_ENTER_NOTIFY)
_clutter_stage_add_device (stage, clutter_event_get_device (event));
else
_clutter_stage_remove_device (stage, clutter_event_get_device (event));
CLUTTER_NOTE (EVENT, "Crossing %s [%.2f, %.2f]",
event->type == CLUTTER_ENTER ? "enter" : "leave",
event->crossing.x,
event->crossing.y);
break;
case GDK_FOCUS_CHANGE:
event = clutter_event_new (CLUTTER_STAGE_STATE);
event->stage_state.time = 0; /* XXX: there is no timestamp in this GdkEvent */
event->stage_state.changed_mask = CLUTTER_STAGE_STATE_ACTIVATED;
event->stage_state.new_state = gdk_event->focus_change.in
? CLUTTER_STAGE_STATE_ACTIVATED
: 0;
break;
case GDK_CONFIGURE:
{
gfloat w, h;
clutter_actor_get_size (CLUTTER_ACTOR (stage), &w, &h);
if (w != gdk_event->configure.width ||
h != gdk_event->configure.height)
{
clutter_actor_set_size (CLUTTER_ACTOR (stage),
gdk_event->configure.width,
gdk_event->configure.height);
}
}
break;
case GDK_SCROLL:
event = clutter_event_new (CLUTTER_SCROLL);
event->scroll.time = gdk_event->scroll.time;
event->scroll.x = gdk_event->scroll.x;
event->scroll.y = gdk_event->scroll.y;
event->scroll.modifier_state = gdk_event->scroll.state;
event->scroll.axes = NULL;
event->scroll.direction = gdk_event->scroll.direction;
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
break;
case GDK_WINDOW_STATE:
event = clutter_event_new (CLUTTER_STAGE_STATE);
event->stage_state.changed_mask = 0;
event->stage_state.new_state = 0;
if (gdk_event->window_state.changed_mask & GDK_WINDOW_STATE_WITHDRAWN)
{
event->stage_state.changed_mask |= CLUTTER_STAGE_STATE_OFFSCREEN;
event->stage_state.new_state |= (gdk_event->window_state.new_window_state & GDK_WINDOW_STATE_WITHDRAWN)
? CLUTTER_STAGE_STATE_OFFSCREEN
: 0;
}
if (gdk_event->window_state.changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
{
event->stage_state.changed_mask |= CLUTTER_STAGE_STATE_FULLSCREEN;
event->stage_state.new_state |= (gdk_event->window_state.new_window_state & GDK_WINDOW_STATE_FULLSCREEN)
? CLUTTER_STAGE_STATE_FULLSCREEN
: 0;
}
break;
case GDK_SETTING:
_clutter_backend_gdk_update_setting (backend_gdk, gdk_event->setting.name);
break;
default:
break;
}
if (event != NULL)
{
event->any.stage = stage;
if (gdk_event->any.send_event)
event->any.flags = CLUTTER_EVENT_FLAG_SYNTHETIC;
_clutter_event_push (event, FALSE);
spin = 1;
CLUTTER_NOTE (EVENT, "Translated one event from Gdk");
/* handle also synthetic enter/leave events */
if (event->type == CLUTTER_MOTION)
spin += 2;
while (spin > 0 && (event = clutter_event_get ()))
{
/* forward the event into clutter for emission etc. */
clutter_do_event (event);
clutter_event_free (event);
--spin;
}
result = GDK_FILTER_REMOVE;
}
clutter_threads_leave ();
return result;
}
Reference in New Issue View Git Blame Copy Permalink