From b9a760c419941dfae6abe1c9d11883a57135325d Mon Sep 17 00:00:00 2001 From: CentOS Buildsys Date: Feb 11 2014 23:00:27 +0000 Subject: import clutter-1.14.4-9.el7.src.rpm --- diff --git a/SOURCES/0001-clutter-text-prevent-reset-of-user-set-font-descript.patch b/SOURCES/0001-clutter-text-prevent-reset-of-user-set-font-descript.patch new file mode 100644 index 0000000..1d76fe9 --- /dev/null +++ b/SOURCES/0001-clutter-text-prevent-reset-of-user-set-font-descript.patch @@ -0,0 +1,66 @@ +From fa933b5ec52d5ade2ca8eddefbd2de35d941c385 Mon Sep 17 00:00:00 2001 +From: Lionel Landwerlin +Date: Tue, 11 Jun 2013 14:01:30 +0100 +Subject: [PATCH] clutter-text: prevent reset of user set font descriptions on + dpi changes + +When setting the font using clutter_text_set_font_description(), the +font settings on a ClutterText actor can be reset when there is a dpi +changes signaled by the backend. + +https://bugzilla.gnome.org/show_bug.cgi?id=702016 +--- + clutter/clutter-text.c | 13 ++++++++----- + 1 file changed, 8 insertions(+), 5 deletions(-) + +diff --git a/clutter/clutter-text.c b/clutter/clutter-text.c +index e0901cd..7b83ad6 100644 +--- a/clutter/clutter-text.c ++++ b/clutter/clutter-text.c +@@ -568,10 +568,13 @@ clutter_text_dirty_cache (ClutterText *text) + */ + static inline void + clutter_text_set_font_description_internal (ClutterText *self, +- PangoFontDescription *desc) ++ PangoFontDescription *desc, ++ gboolean is_default_font) + { + ClutterTextPrivate *priv = self->priv; + ++ priv->is_default_font = is_default_font; ++ + if (priv->font_desc == desc || + pango_font_description_equal (priv->font_desc, desc)) + return; +@@ -619,7 +622,7 @@ clutter_text_settings_changed_cb (ClutterText *text) + font_name); + + font_desc = pango_font_description_from_string (font_name); +- clutter_text_set_font_description_internal (text, font_desc); ++ clutter_text_set_font_description_internal (text, font_desc, TRUE); + + pango_font_description_free (font_desc); + g_free (font_name); +@@ -4945,7 +4948,8 @@ clutter_text_set_font_description (ClutterText *self, + { + g_return_if_fail (CLUTTER_IS_TEXT (self)); + +- clutter_text_set_font_description_internal (self, font_desc); ++ clutter_text_set_font_description_internal (self, font_desc, ++ font_desc == NULL); + } + + /** +@@ -5052,8 +5056,7 @@ clutter_text_set_font_name (ClutterText *self, + } + + /* this will set the font_name field as well */ +- clutter_text_set_font_description_internal (self, desc); +- priv->is_default_font = is_default_font; ++ clutter_text_set_font_description_internal (self, desc, is_default_font); + + g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_FONT_NAME]); + +-- +1.8.3.1 + diff --git a/SOURCES/Bind-constraints-Don-t-force-redraws-on-source-relay.patch b/SOURCES/Bind-constraints-Don-t-force-redraws-on-source-relay.patch new file mode 100644 index 0000000..5d63215 --- /dev/null +++ b/SOURCES/Bind-constraints-Don-t-force-redraws-on-source-relay.patch @@ -0,0 +1,83 @@ +From 0b536c02f97d7adfa8c4af4a4214f02d4ac9f716 Mon Sep 17 00:00:00 2001 +From: "Owen W. Taylor" +Date: Fri, 22 Nov 2013 10:30:21 -0500 +Subject: [PATCH] Bind constraints: Don't force redraws on source relayout + +When the source actor potentially changes size, that shouldn't +necessarily result in the target actor being redrawn - it should +be like when a child of a container is reallocated due to changes +in its siblings or parent - it should redraw only to the extent +that it is moved and resized. Privately export an internal function +from clutter-actor.c to allow getting this right. + +https://bugzilla.gnome.org/show_bug.cgi?id=719367 +--- + clutter/clutter-actor-private.h | 1 + + clutter/clutter-actor.c | 4 +--- + clutter/clutter-bind-constraint.c | 2 +- + clutter/clutter-snap-constraint.c | 2 +- + 4 files changed, 4 insertions(+), 5 deletions(-) + +diff --git a/clutter/clutter-actor-private.h b/clutter/clutter-actor-private.h +index 1c6f165..8bcf26c 100644 +--- a/clutter/clutter-actor-private.h ++++ b/clutter/clutter-actor-private.h +@@ -318,6 +318,7 @@ void _clutter_actor_detach_clone + ClutterActor *clone); + void _clutter_actor_queue_redraw_on_clones (ClutterActor *actor); + void _clutter_actor_queue_relayout_on_clones (ClutterActor *actor); ++void _clutter_actor_queue_only_relayout (ClutterActor *actor); + + G_END_DECLS + +diff --git a/clutter/clutter-actor.c b/clutter/clutter-actor.c +index 4ceb62c..4504ac6 100644 +--- a/clutter/clutter-actor.c ++++ b/clutter/clutter-actor.c +@@ -1037,8 +1037,6 @@ static void clutter_anchor_coord_set_gravity (AnchorCoord *coord + + static gboolean clutter_anchor_coord_is_zero (const AnchorCoord *coord); + +-static void _clutter_actor_queue_only_relayout (ClutterActor *self); +- + static void _clutter_actor_get_relative_transformation_matrix (ClutterActor *self, + ClutterActor *ancestor, + CoglMatrix *matrix); +@@ -8862,7 +8860,7 @@ _clutter_actor_queue_redraw_with_clip (ClutterActor *self, + NULL /* effect */); + } + +-static void ++void + _clutter_actor_queue_only_relayout (ClutterActor *self) + { + ClutterActorPrivate *priv = self->priv; +diff --git a/clutter/clutter-bind-constraint.c b/clutter/clutter-bind-constraint.c +index b9e45ab..fa94906 100644 +--- a/clutter/clutter-bind-constraint.c ++++ b/clutter/clutter-bind-constraint.c +@@ -151,7 +151,7 @@ source_queue_relayout (ClutterActor *source, + ClutterBindConstraint *bind) + { + if (bind->actor != NULL) +- clutter_actor_queue_relayout (bind->actor); ++ _clutter_actor_queue_only_relayout (bind->actor); + } + + static void +diff --git a/clutter/clutter-snap-constraint.c b/clutter/clutter-snap-constraint.c +index c8eaea9..b4c558f 100644 +--- a/clutter/clutter-snap-constraint.c ++++ b/clutter/clutter-snap-constraint.c +@@ -94,7 +94,7 @@ source_queue_relayout (ClutterActor *source, + ClutterSnapConstraint *constraint) + { + if (constraint->actor != NULL) +- clutter_actor_queue_relayout (constraint->actor); ++ _clutter_actor_queue_only_relayout (constraint->actor); + } + + static void +-- +1.8.5.3 + diff --git a/SOURCES/ClutterStageCogl-Ignore-a-clip-the-size-of-the-stage.patch b/SOURCES/ClutterStageCogl-Ignore-a-clip-the-size-of-the-stage.patch new file mode 100644 index 0000000..6017907 --- /dev/null +++ b/SOURCES/ClutterStageCogl-Ignore-a-clip-the-size-of-the-stage.patch @@ -0,0 +1,51 @@ +From cbb9d1e0629f4aa2955291a509d3fba6880b73b9 Mon Sep 17 00:00:00 2001 +From: "Owen W. Taylor" +Date: Wed, 4 Dec 2013 23:54:27 -0500 +Subject: [PATCH] ClutterStageCogl: Ignore a clip the size of the stage + +If the clip region includes the entire stage, ignore it - we aren't +actually clipped. + +https://bugzilla.gnome.org/show_bug.cgi?id=719901 +--- + clutter/cogl/clutter-stage-cogl.c | 14 ++++++++++++-- + 1 file changed, 12 insertions(+), 2 deletions(-) + +diff --git a/clutter/cogl/clutter-stage-cogl.c b/clutter/cogl/clutter-stage-cogl.c +index 6dc3fab..168c70b 100644 +--- a/clutter/cogl/clutter-stage-cogl.c ++++ b/clutter/cogl/clutter-stage-cogl.c +@@ -398,6 +398,8 @@ static void + clutter_stage_cogl_redraw (ClutterStageWindow *stage_window) + { + ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); ++ cairo_rectangle_int_t geom; ++ gboolean have_clip; + gboolean may_use_clipped_redraw; + gboolean use_clipped_redraw; + gboolean can_blit_sub_buffer; +@@ -435,11 +437,19 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window) + + has_buffer_age = cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_BUFFER_AGE); + ++ _clutter_stage_window_get_geometry (stage_window, &geom); ++ ++ /* NB: a zero width redraw clip == full stage redraw */ ++ have_clip = (stage_cogl->bounding_redraw_clip.width != 0 && ++ !(stage_cogl->bounding_redraw_clip.x == 0 && ++ stage_cogl->bounding_redraw_clip.y == 0 && ++ stage_cogl->bounding_redraw_clip.width == geom.width && ++ stage_cogl->bounding_redraw_clip.height == geom.height)); ++ + may_use_clipped_redraw = FALSE; + if (_clutter_stage_window_can_clip_redraws (stage_window) && + can_blit_sub_buffer && +- /* NB: a zero width redraw clip == full stage redraw */ +- stage_cogl->bounding_redraw_clip.width != 0 && ++ have_clip && + /* some drivers struggle to get going and produce some junk + * frames when starting up... */ + stage_cogl->frame_count > 3) +-- +1.8.5.3 + diff --git a/SOURCES/Don-t-queue-redraws-when-reallocating-actor-that-hav.patch b/SOURCES/Don-t-queue-redraws-when-reallocating-actor-that-hav.patch new file mode 100644 index 0000000..8201a8d --- /dev/null +++ b/SOURCES/Don-t-queue-redraws-when-reallocating-actor-that-hav.patch @@ -0,0 +1,59 @@ +From 2e85269368a815435f107f1b7dfbc15c7e806fa6 Mon Sep 17 00:00:00 2001 +From: "Owen W. Taylor" +Date: Tue, 26 Nov 2013 11:04:27 -0500 +Subject: [PATCH] Don't queue redraws when reallocating actor that haven't + moved + +When support for implicit animation of actor position was added, +the optimization for not queueing when allocating an actor back +to the same location was lost. This optimization is important +since when we are hierarchically allocating down from the top of +the stage we constantly reallocate the actors at the top of the +hierarchy back to the same place. + +https://bugzilla.gnome.org/show_bug.cgi?id=719368 +--- + clutter/clutter-actor.c | 13 ++++++++++++- + 1 file changed, 12 insertions(+), 1 deletion(-) + +diff --git a/clutter/clutter-actor.c b/clutter/clutter-actor.c +index 4504ac6..b371183 100644 +--- a/clutter/clutter-actor.c ++++ b/clutter/clutter-actor.c +@@ -9738,7 +9738,9 @@ clutter_actor_allocate_internal (ClutterActor *self, + + CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_RELAYOUT); + +- clutter_actor_queue_redraw (self); ++ /* Caller should call clutter_actor_queue_redraw() if needed ++ * for that particular case. ++ */ + } + + /** +@@ -9847,6 +9849,14 @@ clutter_actor_allocate (ClutterActor *self, + return; + } + ++ if (!stage_allocation_changed) ++ { ++ /* If the actor didn't move but needs_allocation is set, we just ++ * need to allocate the children */ ++ clutter_actor_allocate_internal (self, &real_allocation, flags); ++ return; ++ } ++ + /* When ABSOLUTE_ORIGIN_CHANGED is passed in to + * clutter_actor_allocate(), it indicates whether the parent has its + * absolute origin moved; when passed in to ClutterActor::allocate() +@@ -14718,6 +14728,7 @@ clutter_actor_set_animatable_property (ClutterActor *actor, + clutter_actor_allocate_internal (actor, + g_value_get_boxed (value), + actor->priv->allocation_flags); ++ clutter_actor_queue_redraw (actor); + break; + + case PROP_DEPTH: +-- +1.8.5.3 + diff --git a/SOURCES/xi2-device-manager-cleanups.patch b/SOURCES/xi2-device-manager-cleanups.patch new file mode 100644 index 0000000..af633df --- /dev/null +++ b/SOURCES/xi2-device-manager-cleanups.patch @@ -0,0 +1,1483 @@ +From 5fcfdcb2726637285c256f2b6b8ad75cc619d3a6 Mon Sep 17 00:00:00 2001 +From: "Jasper St. Pierre" +Date: Wed, 10 Jul 2013 16:26:01 -0400 +Subject: [PATCH 1/4] backend-x11: Remove bad branch prediction + +This will only get once, at in Clutter initialization time. + +https://bugzilla.gnome.org/show_bug.cgi?id=703969 +--- + clutter/x11/clutter-backend-x11.c | 105 ++++++++++++++++++-------------------- + 1 file changed, 51 insertions(+), 54 deletions(-) + +diff --git a/clutter/x11/clutter-backend-x11.c b/clutter/x11/clutter-backend-x11.c +index b7cfcc4..9bbfba8 100644 +--- a/clutter/x11/clutter-backend-x11.c ++++ b/clutter/x11/clutter-backend-x11.c +@@ -222,71 +222,68 @@ clutter_backend_x11_xsettings_notify (const char *name, + static void + clutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11) + { +- if (G_UNLIKELY (backend_x11->device_manager == NULL)) +- { +- ClutterEventTranslator *translator; +- ClutterBackend *backend; ++ ClutterEventTranslator *translator; ++ ClutterBackend *backend; + + #if defined(HAVE_XINPUT) || defined(HAVE_XINPUT_2) +- if (clutter_enable_xinput) ++ if (clutter_enable_xinput) ++ { ++ int event_base, first_event, first_error; ++ ++ if (XQueryExtension (backend_x11->xdpy, "XInputExtension", ++ &event_base, ++ &first_event, ++ &first_error)) + { +- int event_base, first_event, first_error; ++#ifdef HAVE_XINPUT_2 ++ int major = 2; ++ int minor = 3; + +- if (XQueryExtension (backend_x11->xdpy, "XInputExtension", +- &event_base, +- &first_event, +- &first_error)) ++ if (XIQueryVersion (backend_x11->xdpy, &major, &minor) != BadRequest) + { +-#ifdef HAVE_XINPUT_2 +- int major = 2; +- int minor = 3; +- +- if (XIQueryVersion (backend_x11->xdpy, &major, &minor) != BadRequest) +- { +- CLUTTER_NOTE (BACKEND, "Creating XI2 device manager"); +- backend_x11->has_xinput = TRUE; +- backend_x11->device_manager = +- g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_XI2, +- "backend", backend_x11, +- "opcode", event_base, +- NULL); +- +- backend_x11->xi_minor = minor; +- } +- else ++ CLUTTER_NOTE (BACKEND, "Creating XI2 device manager"); ++ backend_x11->has_xinput = TRUE; ++ backend_x11->device_manager = ++ g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_XI2, ++ "backend", backend_x11, ++ "opcode", event_base, ++ NULL); ++ ++ backend_x11->xi_minor = minor; ++ } ++ else + #endif /* HAVE_XINPUT_2 */ +- { +- CLUTTER_NOTE (BACKEND, "Creating Core+XI device manager"); +- backend_x11->has_xinput = TRUE; +- backend_x11->device_manager = +- g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11, +- "backend", backend_x11, +- "event-base", first_event, +- NULL); +- +- backend_x11->xi_minor = -1; +- } ++ { ++ CLUTTER_NOTE (BACKEND, "Creating Core+XI device manager"); ++ backend_x11->has_xinput = TRUE; ++ backend_x11->device_manager = ++ g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11, ++ "backend", backend_x11, ++ "event-base", first_event, ++ NULL); ++ ++ backend_x11->xi_minor = -1; + } + } +- else ++ } ++ else + #endif /* HAVE_XINPUT || HAVE_XINPUT_2 */ +- { +- CLUTTER_NOTE (BACKEND, "Creating Core device manager"); +- backend_x11->has_xinput = FALSE; +- backend_x11->device_manager = +- g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11, +- "backend", backend_x11, +- NULL); +- +- backend_x11->xi_minor = -1; +- } +- +- backend = CLUTTER_BACKEND (backend_x11); +- backend->device_manager = backend_x11->device_manager; ++ { ++ CLUTTER_NOTE (BACKEND, "Creating Core device manager"); ++ backend_x11->has_xinput = FALSE; ++ backend_x11->device_manager = ++ g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11, ++ "backend", backend_x11, ++ NULL); + +- translator = CLUTTER_EVENT_TRANSLATOR (backend_x11->device_manager); +- _clutter_backend_add_event_translator (backend, translator); ++ backend_x11->xi_minor = -1; + } ++ ++ backend = CLUTTER_BACKEND (backend_x11); ++ backend->device_manager = backend_x11->device_manager; ++ ++ translator = CLUTTER_EVENT_TRANSLATOR (backend_x11->device_manager); ++ _clutter_backend_add_event_translator (backend, translator); + } + + static void +-- +1.8.4.2 + + +From 3239941d36ae9db92424309f9cdeb3d7f064aa97 Mon Sep 17 00:00:00 2001 +From: "Jasper St. Pierre" +Date: Wed, 10 Jul 2013 16:31:57 -0400 +Subject: [PATCH 2/4] x11: Remove support for XInput 1 + +Now we either use core X11 or XInput 2. + +https://bugzilla.gnome.org/show_bug.cgi?id=703969 + +Conflicts: + clutter/config.h.win32.in +--- + clutter/config.h.win32.in | 3 - + clutter/x11/clutter-backend-x11.c | 31 +-- + clutter/x11/clutter-device-manager-core-x11.c | 230 ---------------- + clutter/x11/clutter-input-device-core-x11.c | 373 -------------------------- + clutter/x11/clutter-input-device-core-x11.h | 5 - + configure.ac | 6 - + 6 files changed, 7 insertions(+), 641 deletions(-) + +diff --git a/clutter/config.h.win32.in b/clutter/config.h.win32.in +index 6040516..e351026 100644 +--- a/clutter/config.h.win32.in ++++ b/clutter/config.h.win32.in +@@ -127,9 +127,6 @@ + /* Define to 1 if X Generic Extensions is available */ + /* #undef HAVE_XGE */ + +-/* Define to 1 if XInput is available */ +-/* #undef HAVE_XINPUT */ +- + /* Define to 1 if XI2 is available */ + /* #undef HAVE_XINPUT_2 */ + +diff --git a/clutter/x11/clutter-backend-x11.c b/clutter/x11/clutter-backend-x11.c +index 9bbfba8..435370c 100644 +--- a/clutter/x11/clutter-backend-x11.c ++++ b/clutter/x11/clutter-backend-x11.c +@@ -50,10 +50,6 @@ + #include + #endif + +-#if HAVE_XINPUT +-#include +-#endif +- + #if HAVE_XINPUT_2 + #include + #endif +@@ -225,7 +221,7 @@ clutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11) + ClutterEventTranslator *translator; + ClutterBackend *backend; + +-#if defined(HAVE_XINPUT) || defined(HAVE_XINPUT_2) ++#ifdef HAVE_XINPUT_2 + if (clutter_enable_xinput) + { + int event_base, first_event, first_error; +@@ -235,7 +231,6 @@ clutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11) + &first_event, + &first_error)) + { +-#ifdef HAVE_XINPUT_2 + int major = 2; + int minor = 3; + +@@ -251,23 +246,11 @@ clutter_backend_x11_create_device_manager (ClutterBackendX11 *backend_x11) + + backend_x11->xi_minor = minor; + } +- else +-#endif /* HAVE_XINPUT_2 */ +- { +- CLUTTER_NOTE (BACKEND, "Creating Core+XI device manager"); +- backend_x11->has_xinput = TRUE; +- backend_x11->device_manager = +- g_object_new (CLUTTER_TYPE_DEVICE_MANAGER_X11, +- "backend", backend_x11, +- "event-base", first_event, +- NULL); +- +- backend_x11->xi_minor = -1; +- } + } + } +- else +-#endif /* HAVE_XINPUT || HAVE_XINPUT_2 */ ++ ++ if (backend_x11->device_manager == NULL) ++#endif /* HAVE_XINPUT_2 */ + { + CLUTTER_NOTE (BACKEND, "Creating Core device manager"); + backend_x11->has_xinput = FALSE; +@@ -514,14 +497,14 @@ static const GOptionEntry entries[] = + G_OPTION_ARG_NONE, &clutter_synchronise, + N_("Make X calls synchronous"), NULL + }, +-#if defined(HAVE_XINPUT) || defined(HAVE_XINPUT_2) ++#ifdef HAVE_XINPUT_2 + { + "disable-xinput", 0, + G_OPTION_FLAG_REVERSE, + G_OPTION_ARG_NONE, &clutter_enable_xinput, + N_("Disable XInput support"), NULL + }, +-#endif /* HAVE_XINPUT */ ++#endif /* HAVE_XINPUT_2 */ + { NULL } + }; + +@@ -1188,7 +1171,7 @@ clutter_x11_get_input_devices (void) + gboolean + clutter_x11_has_xinput (void) + { +-#if defined(HAVE_XINPUT) || defined(HAVE_XINPUT_2) ++#ifdef HAVE_XINPUT_2 + ClutterBackend *backend = clutter_get_default_backend (); + + if (backend == NULL) +diff --git a/clutter/x11/clutter-device-manager-core-x11.c b/clutter/x11/clutter-device-manager-core-x11.c +index f470189..6a3606d 100644 +--- a/clutter/x11/clutter-device-manager-core-x11.c ++++ b/clutter/x11/clutter-device-manager-core-x11.c +@@ -37,17 +37,6 @@ + #include "clutter-stage-private.h" + #include "clutter-private.h" + +-#ifdef HAVE_XINPUT +-#include +- +-/* old versions of XI.h don't define these */ +-#ifndef IsXExtensionKeyboard +-#define IsXExtensionKeyboard 3 +-#define IsXExtensionPointer 4 +-#endif +- +-#endif /* HAVE_XINPUT */ +- + enum + { + PROP_0, +@@ -69,146 +58,6 @@ G_DEFINE_TYPE_WITH_CODE (ClutterDeviceManagerX11, + G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_EVENT_TRANSLATOR, + clutter_event_translator_iface_init)); + +-#ifdef HAVE_XINPUT +-static void +-translate_class_info (ClutterInputDevice *device, +- XDeviceInfo *info) +-{ +- XAnyClassPtr any_class; +- gint i; +- +- any_class = info->inputclassinfo; +- +- for (i = 0; i < info->num_classes; i++) +- { +- switch (any_class->class) +- { +- case ButtonClass: +- break; +- +- case KeyClass: +- { +- XKeyInfo *xk_info = (XKeyInfo *) any_class; +- ClutterInputDeviceX11 *device_x11; +- guint n_keys; +- +- device_x11 = CLUTTER_INPUT_DEVICE_X11 (device); +- +- n_keys = xk_info->max_keycode - xk_info->min_keycode + 1; +- +- _clutter_input_device_set_n_keys (device, n_keys); +- _clutter_input_device_x11_set_keycodes (device_x11, +- xk_info->min_keycode, +- xk_info->max_keycode); +- } +- break; +- +- case ValuatorClass: +- { +- XValuatorInfo *xv_info = (XValuatorInfo *) any_class; +- gint j; +- +- for (j = 0; j < xv_info->num_axes; j++) +- { +- ClutterInputAxis axis; +- +- switch (j) +- { +- case 0: +- axis = CLUTTER_INPUT_AXIS_X; +- break; +- +- case 1: +- axis = CLUTTER_INPUT_AXIS_Y; +- break; +- +- case 2: +- axis = CLUTTER_INPUT_AXIS_PRESSURE; +- break; +- +- case 3: +- axis = CLUTTER_INPUT_AXIS_XTILT; +- break; +- +- case 4: +- axis = CLUTTER_INPUT_AXIS_YTILT; +- break; +- +- case 5: +- axis = CLUTTER_INPUT_AXIS_WHEEL; +- break; +- +- default: +- axis = CLUTTER_INPUT_AXIS_IGNORE; +- break; +- } +- +- _clutter_input_device_add_axis (device, axis, +- xv_info->axes[j].min_value, +- xv_info->axes[j].max_value, +- xv_info->axes[j].resolution); +- } +- } +- break; +- } +- +- any_class = (XAnyClassPtr) (((char *) any_class) + any_class->length); +- } +-} +- +-static ClutterInputDevice * +-create_device (ClutterDeviceManagerX11 *manager_x11, +- ClutterBackendX11 *backend_x11, +- XDeviceInfo *info) +-{ +- ClutterInputDeviceType source; +- ClutterInputDevice *retval; +- +- if (info->use != IsXExtensionPointer && +- info->use != IsXExtensionKeyboard) +- return NULL; +- +- if (info->use == IsXExtensionKeyboard) +- source = CLUTTER_KEYBOARD_DEVICE; +- else +- { +- gchar *name; +- +- name = g_ascii_strdown (info->name, -1); +- +- if (strstr (name, "eraser") != NULL) +- source = CLUTTER_ERASER_DEVICE; +- else if (strstr (name, "cursor") != NULL) +- source = CLUTTER_CURSOR_DEVICE; +- else if (strstr (name, "wacom") != NULL || strstr (name, "pen") != NULL) +- source = CLUTTER_PEN_DEVICE; +- else +- source = CLUTTER_POINTER_DEVICE; +- +- g_free (name); +- } +- +- retval = g_object_new (CLUTTER_TYPE_INPUT_DEVICE_X11, +- "name", info->name, +- "id", info->id, +- "has-cursor", FALSE, +- "device-manager", manager_x11, +- "device-type", source, +- "device-mode", CLUTTER_INPUT_MODE_FLOATING, +- "backend", backend_x11, +- "enabled", FALSE, +- NULL); +- translate_class_info (retval, info); +- +- CLUTTER_NOTE (BACKEND, +- "XI Device '%s' (id: %d) created", +- info->name, +- (int) info->id); +- +- return retval; +-} +-#endif /* HAVE_XINPUT */ +- + static inline void + translate_key_event (ClutterBackendX11 *backend_x11, + ClutterDeviceManagerX11 *manager_x11, +@@ -275,20 +124,6 @@ out: + return; + } + +-#ifdef HAVE_XINPUT +-static ClutterInputDevice * +-get_device_from_event (ClutterDeviceManagerX11 *manager_x11, +- XEvent *xevent) +-{ +- guint32 device_id; +- +- device_id = ((XDeviceButtonEvent *) xevent)->deviceid; +- +- return g_hash_table_lookup (manager_x11->devices_by_id, +- GINT_TO_POINTER (device_id)); +-} +-#endif /* HAVE_XINPUT */ +- + static ClutterTranslateReturn + clutter_device_manager_x11_translate_event (ClutterEventTranslator *translator, + gpointer native, +@@ -300,9 +135,6 @@ clutter_device_manager_x11_translate_event (ClutterEventTranslator *translator, + ClutterTranslateReturn res; + ClutterStage *stage; + XEvent *xevent; +-#ifdef HAVE_XINPUT +- ClutterInputDevice *device; +-#endif + + manager_x11 = CLUTTER_DEVICE_MANAGER_X11 (translator); + backend_x11 = CLUTTER_BACKEND_X11 (clutter_get_default_backend ()); +@@ -322,23 +154,6 @@ clutter_device_manager_x11_translate_event (ClutterEventTranslator *translator, + + res = CLUTTER_TRANSLATE_CONTINUE; + +-#ifdef HAVE_XINPUT +- device = get_device_from_event (manager_x11, xevent); +- if (device != NULL) +- { +- ClutterInputDeviceX11 *device_x11; +- gboolean retval; +- +- device_x11 = CLUTTER_INPUT_DEVICE_X11 (device); +- retval = _clutter_input_device_x11_translate_xi_event (device_x11, +- stage_x11, +- xevent, +- event); +- if (retval) +- return CLUTTER_TRANSLATE_QUEUE; +- } +-#endif /* HAVE_XINPUT */ +- + switch (xevent->type) + { + case KeyPress: +@@ -537,57 +352,12 @@ clutter_device_manager_x11_constructed (GObject *gobject) + { + ClutterDeviceManagerX11 *manager_x11; + ClutterBackendX11 *backend_x11; +-#ifdef HAVE_XINPUT +- ClutterDeviceManager *manager; +- XDeviceInfo *x_devices = NULL; +- int i, n_devices; +-#endif /* HAVE_XINPUT */ + + manager_x11 = CLUTTER_DEVICE_MANAGER_X11 (gobject); + + g_object_get (gobject, "backend", &backend_x11, NULL); + g_assert (backend_x11 != NULL); + +-#ifdef HAVE_XINPUT +- manager = CLUTTER_DEVICE_MANAGER (gobject); +- x_devices = XListInputDevices (backend_x11->xdpy, &n_devices); +- if (n_devices == 0) +- { +- CLUTTER_NOTE (BACKEND, "No XInput devices found"); +- goto default_device; +- } +- +- for (i = 0; i < n_devices; i++) +- { +- XDeviceInfo *info = x_devices + i; +- ClutterInputDevice *device; +- +- CLUTTER_NOTE (BACKEND, +- "Considering device %li with type %d, %d of %d", +- info->id, +- info->use, +- i, n_devices); +- +- device = create_device (manager_x11, backend_x11, info); +- if (device != NULL) +- _clutter_device_manager_add_device (manager, device); +- } +- +- XFreeDeviceList (x_devices); +- +-default_device: +-#endif /* HAVE_XINPUT */ +- +- /* fallback code in case: +- * +- * - we do not have XInput support compiled in +- * - we do not have the XInput extension +- * +- * we register two default devices, one for the pointer +- * and one for the keyboard. this block must also be +- * executed for the XInput support because XI does not +- * cover core devices +- */ + manager_x11->core_pointer = + g_object_new (CLUTTER_TYPE_INPUT_DEVICE_X11, + "name", "Core Pointer", +diff --git a/clutter/x11/clutter-input-device-core-x11.c b/clutter/x11/clutter-input-device-core-x11.c +index 6c78a30..0835c17 100644 +--- a/clutter/x11/clutter-input-device-core-x11.c ++++ b/clutter/x11/clutter-input-device-core-x11.c +@@ -33,12 +33,6 @@ + #include "clutter-backend-x11.h" + #include "clutter-stage-x11.h" + +-#ifdef HAVE_XINPUT +-#include +-#endif +- +-#define MAX_DEVICE_CLASSES 13 +- + typedef struct _ClutterInputDeviceClass ClutterInputDeviceX11Class; + + /* a specific X11 input device */ +@@ -46,22 +40,6 @@ struct _ClutterInputDeviceX11 + { + ClutterInputDevice device; + +-#ifdef HAVE_XINPUT +- XDevice *xdevice; +- +- XEventClass event_classes[MAX_DEVICE_CLASSES]; +- int num_classes; +- +- int button_press_type; +- int button_release_type; +- int motion_notify_type; +- int state_notify_type; +- int key_press_type; +- int key_release_type; +-#endif /* HAVE_XINPUT */ +- +- gint *axis_data; +- + int min_keycode; + int max_keycode; + }; +@@ -72,134 +50,6 @@ G_DEFINE_TYPE (ClutterInputDeviceX11, + clutter_input_device_x11, + CLUTTER_TYPE_INPUT_DEVICE); + +-static void +-clutter_input_device_x11_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage, +- gint event_mask) +-{ +-#if HAVE_XINPUT +- ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (device->backend); +- ClutterInputDeviceX11 *device_x11; +- ClutterStageX11 *stage_x11; +- XEventClass class; +- gint i; +- +- device_x11 = CLUTTER_INPUT_DEVICE_X11 (device); +- +- stage_x11 = CLUTTER_STAGE_X11 (_clutter_stage_get_window (stage)); +- +- i = 0; +- +- if (event_mask & ButtonPressMask) +- { +- DeviceButtonPress (device_x11->xdevice, +- device_x11->button_press_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- +- DeviceButtonPressGrab (device_x11->xdevice, 0, class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- } +- +- if (event_mask & ButtonReleaseMask) +- { +- DeviceButtonRelease (device_x11->xdevice, +- device_x11->button_release_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- } +- +- if (event_mask & PointerMotionMask) +- { +- DeviceMotionNotify (device_x11->xdevice, +- device_x11->motion_notify_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- +- DeviceStateNotify (device_x11->xdevice, +- device_x11->state_notify_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- } +- +- if (event_mask & KeyPressMask) +- { +- DeviceKeyPress (device_x11->xdevice, +- device_x11->key_press_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- } +- +- if (event_mask & KeyReleaseMask) +- { +- DeviceKeyRelease (device_x11->xdevice, +- device_x11->key_release_type, +- class); +- if (class != 0) +- device_x11->event_classes[i++] = class; +- } +- +- device_x11->num_classes = i; +- +- XSelectExtensionEvent (backend_x11->xdpy, +- stage_x11->xwin, +- device_x11->event_classes, +- device_x11->num_classes); +-#endif /* HAVE_XINPUT */ +-} +- +-static void +-clutter_input_device_x11_dispose (GObject *gobject) +-{ +- ClutterInputDeviceX11 *device_x11 = CLUTTER_INPUT_DEVICE_X11 (gobject); +- +-#ifdef HAVE_XINPUT +- if (device_x11->xdevice) +- { +- ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (gobject); +- ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (device->backend); +- +- XCloseDevice (backend_x11->xdpy, device_x11->xdevice); +- device_x11->xdevice = NULL; +- } +-#endif /* HAVE_XINPUT */ +- +- g_free (device_x11->axis_data); +- +- G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->dispose (gobject); +-} +- +-static void +-clutter_input_device_x11_constructed (GObject *gobject) +-{ +-#ifdef HAVE_XINPUT +- ClutterInputDeviceX11 *device_x11 = CLUTTER_INPUT_DEVICE_X11 (gobject); +- ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (gobject); +- ClutterBackendX11 *backend_x11; +- +- backend_x11 = CLUTTER_BACKEND_X11 (device->backend); +- +- clutter_x11_trap_x_errors (); +- +- device_x11->xdevice = XOpenDevice (backend_x11->xdpy, device->id); +- +- if (clutter_x11_untrap_x_errors ()) +- { +- g_warning ("Device '%s' cannot be opened", +- clutter_input_device_get_device_name (device)); +- } +-#endif /* HAVE_XINPUT */ +- +- if (G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->constructed) +- G_OBJECT_CLASS (clutter_input_device_x11_parent_class)->constructed (gobject); +-} +- + static gboolean + clutter_input_device_x11_keycode_to_evdev (ClutterInputDevice *device, + guint hardware_keycode, +@@ -220,10 +70,6 @@ clutter_input_device_x11_class_init (ClutterInputDeviceX11Class *klass) + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + ClutterInputDeviceClass *device_class = CLUTTER_INPUT_DEVICE_CLASS (klass); + +- gobject_class->constructed = clutter_input_device_x11_constructed; +- gobject_class->dispose = clutter_input_device_x11_dispose; +- +- device_class->select_stage_events = clutter_input_device_x11_select_stage_events; + device_class->keycode_to_evdev = clutter_input_device_x11_keycode_to_evdev; + } + +@@ -252,222 +98,3 @@ _clutter_input_device_x11_get_max_keycode (ClutterInputDeviceX11 *device_x11) + { + return device_x11->max_keycode; + } +- +-#ifdef HAVE_XINPUT +-static void +-update_axes (ClutterInputDeviceX11 *device_x11, +- guint n_axes, +- gint first_axis, +- gint *axes_data) +-{ +- ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11); +- gint i; +- +- if (device_x11->axis_data == NULL) +- { +- device_x11->axis_data = +- g_new0 (gint, clutter_input_device_get_n_axes (device)); +- } +- +- for (i = 0; i < n_axes; i++) +- device_x11->axis_data[first_axis + i] = axes_data[i]; +-} +- +-static gdouble * +-translate_axes (ClutterInputDeviceX11 *device_x11, +- ClutterStageX11 *stage_x11, +- gfloat *event_x, +- gfloat *event_y) +-{ +- ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11); +- gint root_x, root_y; +- gint n_axes, i; +- gdouble x, y; +- gdouble *retval; +- +- if (!_clutter_stage_x11_get_root_coords (stage_x11, &root_x, &root_y)) +- return NULL; +- +- x = y = 0.0f; +- n_axes = clutter_input_device_get_n_axes (device); +- +- retval = g_new0 (gdouble, n_axes); +- +- for (i = 0; i < n_axes; i++) +- { +- ClutterInputAxis axis; +- +- axis = clutter_input_device_get_axis (device, i); +- switch (axis) +- { +- case CLUTTER_INPUT_AXIS_X: +- case CLUTTER_INPUT_AXIS_Y: +- _clutter_x11_input_device_translate_screen_coord (device, +- root_x, root_y, +- i, +- device_x11->axis_data[i], +- &retval[i]); +- if (axis == CLUTTER_INPUT_AXIS_X) +- x = retval[i]; +- else if (axis == CLUTTER_INPUT_AXIS_Y) +- y = retval[i]; +- break; +- +- default: +- _clutter_input_device_translate_axis (device, i, +- device_x11->axis_data[i], +- &retval[i]); +- break; +- } +- } +- +- if (event_x) +- *event_x = x; +- +- if (event_y) +- *event_y = y; +- +- return retval; +-} +- +-/* +- * translate_state: +- * @state: the keyboard state of the core device +- * @device_state: the button state of the device +- * +- * Trivially translates the state and the device state into a +- * single bitmask. +- */ +-static guint +-translate_state (guint state, +- guint device_state) +-{ +- return device_state | (state & 0xff); +-} +-#endif /* HAVE_XINPUT */ +- +-gboolean +-_clutter_input_device_x11_translate_xi_event (ClutterInputDeviceX11 *device_x11, +- ClutterStageX11 *stage_x11, +- XEvent *xevent, +- ClutterEvent *event) +-{ +-#ifdef HAVE_XINPUT +- ClutterInputDevice *device = CLUTTER_INPUT_DEVICE (device_x11); +- +- if ((xevent->type == device_x11->button_press_type) || +- (xevent->type == device_x11->button_release_type)) +- { +- XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *) xevent; +- +- event->button.type = event->type = +- (xdbe->type == device_x11->button_press_type) ? CLUTTER_BUTTON_PRESS +- : CLUTTER_BUTTON_RELEASE; +- event->button.device = device; +- event->button.time = xdbe->time; +- event->button.button = xdbe->button; +- event->button.modifier_state = +- translate_state (xdbe->state, xdbe->device_state); +- +- update_axes (device_x11, +- xdbe->axes_count, +- xdbe->first_axis, +- xdbe->axis_data); +- +- event->button.axes = translate_axes (device_x11, stage_x11, +- &event->button.x, +- &event->button.y); +- +- _clutter_stage_x11_set_user_time (stage_x11, event->button.time); +- +- return TRUE; +- } +- +- if ((xevent->type == device_x11->key_press_type) || +- (xevent->type == device_x11->key_release_type)) +- { +- XDeviceKeyEvent *xdke = (XDeviceKeyEvent *) xevent; +- +- if (xdke->keycode < device_x11->min_keycode || +- xdke->keycode >= device_x11->max_keycode) +- { +- g_warning ("Invalid device key code received: %d", xdke->keycode); +- return FALSE; +- } +- +- clutter_input_device_get_key (device, +- xdke->keycode - device_x11->min_keycode, +- &event->key.keyval, +- &event->key.modifier_state); +- if (event->key.keyval == 0) +- return FALSE; +- +- event->key.type = event->type = +- (xdke->type == device_x11->key_press_type) ? CLUTTER_KEY_PRESS +- : CLUTTER_KEY_RELEASE; +- event->key.time = xdke->time; +- event->key.modifier_state |= +- translate_state (xdke->state, xdke->device_state); +- event->key.device = device; +- +-#if 0 +- if ((event->key.keyval >= 0x20) && (event->key.keyval <= 0xff)) +- { +- event->key.unicode = (gunichar) event->key.keyval; +- } +-#endif +- +- _clutter_stage_x11_set_user_time (stage_x11, event->key.time); +- +- return TRUE; +- } +- +- if (xevent->type == device_x11->motion_notify_type) +- { +- XDeviceMotionEvent *xdme = (XDeviceMotionEvent *) xevent; +- +- event->motion.type = event->type = CLUTTER_MOTION; +- event->motion.time = xdme->time; +- event->motion.modifier_state = +- translate_state (xdme->state, xdme->device_state); +- event->motion.device = device; +- +- event->motion.axes = +- g_new0 (gdouble, clutter_input_device_get_n_axes (device)); +- +- update_axes (device_x11, +- xdme->axes_count, +- xdme->first_axis, +- xdme->axis_data); +- +- event->motion.axes = translate_axes (device_x11, stage_x11, +- &event->motion.x, +- &event->motion.y); +- +- return TRUE; +- } +- +- if (xevent->type == device_x11->state_notify_type) +- { +- XDeviceStateNotifyEvent *xdse = (XDeviceStateNotifyEvent *) xevent; +- XInputClass *input_class = (XInputClass *) xdse->data; +- gint n_axes = clutter_input_device_get_n_axes (device); +- int i; +- +- for (i = 0; i < xdse->num_classes; i++) +- { +- if (input_class->class == ValuatorClass) +- { +- int *axis_data = ((XValuatorState *) input_class)->valuators; +- +- update_axes (device_x11, n_axes, 0, axis_data); +- } +- +- input_class = +- (XInputClass *)(((char *) input_class) + input_class->length); +- } +- } +-#endif /* HAVE_XINPUT */ +- +- return FALSE; +-} +diff --git a/clutter/x11/clutter-input-device-core-x11.h b/clutter/x11/clutter-input-device-core-x11.h +index af4ed59..ce6b125 100644 +--- a/clutter/x11/clutter-input-device-core-x11.h ++++ b/clutter/x11/clutter-input-device-core-x11.h +@@ -45,11 +45,6 @@ void _clutter_input_device_x11_set_keycodes (ClutterInputDeviceX11 *device_x11, + int _clutter_input_device_x11_get_min_keycode (ClutterInputDeviceX11 *device_x11); + int _clutter_input_device_x11_get_max_keycode (ClutterInputDeviceX11 *device_x11); + +-gboolean _clutter_input_device_x11_translate_xi_event (ClutterInputDeviceX11 *device_x11, +- ClutterStageX11 *stage_x11, +- XEvent *xevent, +- ClutterEvent *event); +- + G_END_DECLS + + #endif /* __CLUTTER_INPUT_DEVICE_X11_H__ */ +diff --git a/configure.ac b/configure.ac +index 8dcbf58..47c32d2 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -717,12 +717,6 @@ AS_IF([test "x$SUPPORT_X11" = "x1"], + AC_DEFINE([HAVE_XINPUT_2], + [1], + [Define to 1 if XI2 is available]) +- ], +- [ +- have_xinput2=no +- AC_DEFINE([HAVE_XINPUT], +- [1], +- [Define to 1 if XInput is available]) + ]) + + clutter_save_LIBS="$LIBS" +-- +1.8.4.2 + + +From 97584c62c11057944645fb6efab53bdee16ee20e Mon Sep 17 00:00:00 2001 +From: "Jasper St. Pierre" +Date: Wed, 10 Jul 2013 16:34:48 -0400 +Subject: [PATCH 3/4] device-manager: Don't pass the event mask around + +There's no point in doing this, as we always use a constant event mask. +Simply do what everything else does. + +https://bugzilla.gnome.org/show_bug.cgi?id=703969 +--- + clutter/clutter-device-manager-private.h | 9 +++------ + clutter/clutter-device-manager.c | 5 ++--- + clutter/clutter-input-device.c | 6 ++---- + clutter/x11/clutter-input-device-xi2.c | 30 ++++++++---------------------- + clutter/x11/clutter-stage-x11.c | 26 +++++--------------------- + clutter/x11/clutter-stage-x11.h | 2 +- + 6 files changed, 21 insertions(+), 57 deletions(-) + +diff --git a/clutter/clutter-device-manager-private.h b/clutter/clutter-device-manager-private.h +index 8bc5330..631a776 100644 +--- a/clutter/clutter-device-manager-private.h ++++ b/clutter/clutter-device-manager-private.h +@@ -138,8 +138,7 @@ struct _ClutterInputDeviceClass + GObjectClass parent_class; + + void (* select_stage_events) (ClutterInputDevice *device, +- ClutterStage *stage, +- gint event_mask); ++ ClutterStage *stage); + gboolean (* keycode_to_evdev) (ClutterInputDevice *device, + guint hardware_keycode, + guint *evdev_keycode); +@@ -152,8 +151,7 @@ void _clutter_device_manager_remove_device (ClutterDeviceMa + ClutterInputDevice *device); + void _clutter_device_manager_update_devices (ClutterDeviceManager *device_manager); + void _clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manager, +- ClutterStage *stage, +- gint event_mask); ++ ClutterStage *stage); + ClutterBackend *_clutter_device_manager_get_backend (ClutterDeviceManager *device_manager); + + /* input device */ +@@ -199,8 +197,7 @@ void _clutter_input_device_remove_slave (ClutterInputDev + ClutterInputDevice *slave); + + void _clutter_input_device_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage, +- gint event_flags); ++ ClutterStage *stage); + + gboolean _clutter_input_device_translate_axis (ClutterInputDevice *device, + guint index_, +diff --git a/clutter/clutter-device-manager.c b/clutter/clutter-device-manager.c +index 2dc67be..c54b3e0 100644 +--- a/clutter/clutter-device-manager.c ++++ b/clutter/clutter-device-manager.c +@@ -308,8 +308,7 @@ clutter_device_manager_get_core_device (ClutterDeviceManager *device_manager, + + void + _clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manager, +- ClutterStage *stage, +- gint event_flags) ++ ClutterStage *stage) + { + ClutterDeviceManagerClass *manager_class; + const GSList *devices, *d; +@@ -324,7 +323,7 @@ _clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manage + ClutterInputDevice *device = d->data; + + if (device->is_enabled) +- _clutter_input_device_select_stage_events (device, stage, event_flags); ++ _clutter_input_device_select_stage_events (device, stage); + } + } + +diff --git a/clutter/clutter-input-device.c b/clutter/clutter-input-device.c +index d222177..48cb40a 100644 +--- a/clutter/clutter-input-device.c ++++ b/clutter/clutter-input-device.c +@@ -1624,7 +1624,6 @@ clutter_input_device_get_associated_device (ClutterInputDevice *device) + * clutter_input_device_select_stage_events: + * @device: a #ClutterInputDevice + * @stage: the #ClutterStage to select events on +- * @event_mask: platform-specific mask of events + * + * Selects input device events on @stage. + * +@@ -1632,14 +1631,13 @@ clutter_input_device_get_associated_device (ClutterInputDevice *device) + */ + void + _clutter_input_device_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage, +- gint event_mask) ++ ClutterStage *stage) + { + ClutterInputDeviceClass *device_class; + + device_class = CLUTTER_INPUT_DEVICE_GET_CLASS (device); + if (device_class->select_stage_events != NULL) +- device_class->select_stage_events (device, stage, event_mask); ++ device_class->select_stage_events (device, stage); + } + + /** +diff --git a/clutter/x11/clutter-input-device-xi2.c b/clutter/x11/clutter-input-device-xi2.c +index 5923977..cd65b7b 100644 +--- a/clutter/x11/clutter-input-device-xi2.c ++++ b/clutter/x11/clutter-input-device-xi2.c +@@ -55,8 +55,7 @@ G_DEFINE_TYPE (ClutterInputDeviceXI2, + + static void + clutter_input_device_xi2_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage, +- gint event_mask) ++ ClutterStage *stage) + { + ClutterInputDeviceXI2 *device_xi2 = CLUTTER_INPUT_DEVICE_XI2 (device); + ClutterBackendX11 *backend_x11; +@@ -71,26 +70,13 @@ clutter_input_device_xi2_select_stage_events (ClutterInputDevice *device, + len = XIMaskLen (XI_LASTEVENT); + mask = g_new0 (unsigned char, len); + +- if (event_mask & PointerMotionMask) +- XISetMask (mask, XI_Motion); +- +- if (event_mask & ButtonPressMask) +- XISetMask (mask, XI_ButtonPress); +- +- if (event_mask & ButtonReleaseMask) +- XISetMask (mask, XI_ButtonRelease); +- +- if (event_mask & KeyPressMask) +- XISetMask (mask, XI_KeyPress); +- +- if (event_mask & KeyReleaseMask) +- XISetMask (mask, XI_KeyRelease); +- +- if (event_mask & EnterWindowMask) +- XISetMask (mask, XI_Enter); +- +- if (event_mask & LeaveWindowMask) +- XISetMask (mask, XI_Leave); ++ XISetMask (mask, XI_Motion); ++ XISetMask (mask, XI_ButtonPress); ++ XISetMask (mask, XI_ButtonRelease); ++ XISetMask (mask, XI_KeyPress); ++ XISetMask (mask, XI_KeyRelease); ++ XISetMask (mask, XI_Enter); ++ XISetMask (mask, XI_Leave); + + #ifdef HAVE_XINPUT_2_2 + /* enable touch event support if we're running on XInput 2.2 */ +diff --git a/clutter/x11/clutter-stage-x11.c b/clutter/x11/clutter-stage-x11.c +index 230172c..08b8e15 100644 +--- a/clutter/x11/clutter-stage-x11.c ++++ b/clutter/x11/clutter-stage-x11.c +@@ -547,14 +547,10 @@ _clutter_stage_x11_events_device_changed (ClutterStageX11 *stage_x11, + ClutterDeviceManager *device_manager) + { + ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_x11); +- int event_flags = 0; + + if (clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_FLOATING) +- event_flags = CLUTTER_STAGE_X11_EVENT_MASK; +- +- _clutter_device_manager_select_stage_events (device_manager, +- stage_cogl->wrapper, +- event_flags); ++ _clutter_device_manager_select_stage_events (device_manager, ++ stage_cogl->wrapper); + } + + static void +@@ -564,12 +560,10 @@ stage_events_device_added (ClutterDeviceManager *device_manager, + { + ClutterStageWindow *stage_window = user_data; + ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); +- int event_flags = CLUTTER_STAGE_X11_EVENT_MASK; + + if (clutter_input_device_get_device_mode (device) == CLUTTER_INPUT_MODE_FLOATING) + _clutter_device_manager_select_stage_events (device_manager, +- stage_cogl->wrapper, +- event_flags); ++ stage_cogl->wrapper); + } + + static gboolean +@@ -580,7 +574,6 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window) + ClutterBackend *backend = CLUTTER_BACKEND (stage_cogl->backend); + ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend); + ClutterDeviceManager *device_manager; +- int event_flags; + gfloat width, height; + + clutter_actor_get_size (CLUTTER_ACTOR (stage_cogl->wrapper), +@@ -623,14 +616,6 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window) + set_wm_title (stage_x11); + set_cursor_visible (stage_x11); + +- +- /* the masks for the events we want to select on a stage window; +- * KeyPressMask and KeyReleaseMask are necessary even with XI1 +- * because key events are broken with that extension, and will +- * be fixed by XI2 +- */ +- event_flags = CLUTTER_STAGE_X11_EVENT_MASK; +- + /* we unconditionally select input events even with event retrieval + * disabled because we need to guarantee that the Clutter internal + * state is maintained when calling clutter_x11_handle_event() without +@@ -648,7 +633,7 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window) + * for an example of things that break if we do conditional event + * selection. + */ +- XSelectInput (backend_x11->xdpy, stage_x11->xwin, event_flags); ++ XSelectInput (backend_x11->xdpy, stage_x11->xwin, CLUTTER_STAGE_X11_EVENT_MASK); + + /* input events also depent on the actual device, so we need to + * use the device manager to let every device select them, using +@@ -658,8 +643,7 @@ clutter_stage_x11_realize (ClutterStageWindow *stage_window) + if (G_UNLIKELY (device_manager != NULL)) + { + _clutter_device_manager_select_stage_events (device_manager, +- stage_cogl->wrapper, +- event_flags); ++ stage_cogl->wrapper); + + g_signal_connect (device_manager, "device-added", + G_CALLBACK (stage_events_device_added), +diff --git a/clutter/x11/clutter-stage-x11.h b/clutter/x11/clutter-stage-x11.h +index c7a7a1b..8b61056 100644 +--- a/clutter/x11/clutter-stage-x11.h ++++ b/clutter/x11/clutter-stage-x11.h +@@ -86,7 +86,7 @@ struct _ClutterStageX11Class + KeyReleaseMask | \ + ButtonPressMask | \ + ButtonReleaseMask | \ +- PointerMotionMask; ++ PointerMotionMask + + GType _clutter_stage_x11_get_type (void) G_GNUC_CONST; + +-- +1.8.4.2 + + +From 95eb3eb5759644d671fab54142f1a43c3cd1c48e Mon Sep 17 00:00:00 2001 +From: "Jasper St. Pierre" +Date: Wed, 10 Jul 2013 16:53:26 -0400 +Subject: [PATCH 4/4] device-manager: Select for events on XIAllMasterDevices + +This removes a bit of work that we have to do for every device, and makes it +easy for mutter to patch out parts of the event mask it doesn't want. + +https://bugzilla.gnome.org/show_bug.cgi?id=703969 +--- + clutter/clutter-device-manager-private.h | 5 ---- + clutter/clutter-device-manager.c | 12 ++------ + clutter/clutter-device-manager.h | 4 ++- + clutter/clutter-input-device.c | 20 ------------- + clutter/x11/clutter-device-manager-xi2.c | 44 +++++++++++++++++++++++++++++ + clutter/x11/clutter-input-device-xi2.c | 48 -------------------------------- + 6 files changed, 49 insertions(+), 84 deletions(-) + +diff --git a/clutter/clutter-device-manager-private.h b/clutter/clutter-device-manager-private.h +index 631a776..826b2f6 100644 +--- a/clutter/clutter-device-manager-private.h ++++ b/clutter/clutter-device-manager-private.h +@@ -137,8 +137,6 @@ struct _ClutterInputDeviceClass + { + GObjectClass parent_class; + +- void (* select_stage_events) (ClutterInputDevice *device, +- ClutterStage *stage); + gboolean (* keycode_to_evdev) (ClutterInputDevice *device, + guint hardware_keycode, + guint *evdev_keycode); +@@ -196,9 +194,6 @@ void _clutter_input_device_add_slave (ClutterInputDev + void _clutter_input_device_remove_slave (ClutterInputDevice *master, + ClutterInputDevice *slave); + +-void _clutter_input_device_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage); +- + gboolean _clutter_input_device_translate_axis (ClutterInputDevice *device, + guint index_, + gdouble value, +diff --git a/clutter/clutter-device-manager.c b/clutter/clutter-device-manager.c +index c54b3e0..fde30ea 100644 +--- a/clutter/clutter-device-manager.c ++++ b/clutter/clutter-device-manager.c +@@ -311,20 +311,12 @@ _clutter_device_manager_select_stage_events (ClutterDeviceManager *device_manage + ClutterStage *stage) + { + ClutterDeviceManagerClass *manager_class; +- const GSList *devices, *d; + + g_return_if_fail (CLUTTER_IS_DEVICE_MANAGER (device_manager)); + + manager_class = CLUTTER_DEVICE_MANAGER_GET_CLASS (device_manager); +- devices = manager_class->get_devices (device_manager); +- +- for (d = devices; d != NULL; d = d->next) +- { +- ClutterInputDevice *device = d->data; +- +- if (device->is_enabled) +- _clutter_input_device_select_stage_events (device, stage); +- } ++ if (manager_class->select_stage_events) ++ manager_class->select_stage_events (device_manager, stage); + } + + /* +diff --git a/clutter/clutter-device-manager.h b/clutter/clutter-device-manager.h +index 94cde3d..49b0f94 100644 +--- a/clutter/clutter-device-manager.h ++++ b/clutter/clutter-device-manager.h +@@ -81,9 +81,11 @@ struct _ClutterDeviceManagerClass + ClutterInputDevice *device); + void (* remove_device) (ClutterDeviceManager *manager, + ClutterInputDevice *device); ++ void (* select_stage_events) (ClutterDeviceManager *manager, ++ ClutterStage *stage); + + /* padding */ +- gpointer _padding[8]; ++ gpointer _padding[7]; + }; + + +diff --git a/clutter/clutter-input-device.c b/clutter/clutter-input-device.c +index 48cb40a..6aed92b 100644 +--- a/clutter/clutter-input-device.c ++++ b/clutter/clutter-input-device.c +@@ -1620,26 +1620,6 @@ clutter_input_device_get_associated_device (ClutterInputDevice *device) + return device->associated; + } + +-/*< internal > +- * clutter_input_device_select_stage_events: +- * @device: a #ClutterInputDevice +- * @stage: the #ClutterStage to select events on +- * +- * Selects input device events on @stage. +- * +- * The implementation of this function depends on the backend used. +- */ +-void +-_clutter_input_device_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage) +-{ +- ClutterInputDeviceClass *device_class; +- +- device_class = CLUTTER_INPUT_DEVICE_GET_CLASS (device); +- if (device_class->select_stage_events != NULL) +- device_class->select_stage_events (device, stage); +-} +- + /** + * clutter_input_device_keycode_to_evdev: + * @device: A #ClutterInputDevice +diff --git a/clutter/x11/clutter-device-manager-xi2.c b/clutter/x11/clutter-device-manager-xi2.c +index 49ee212..e5664d8 100644 +--- a/clutter/x11/clutter-device-manager-xi2.c ++++ b/clutter/x11/clutter-device-manager-xi2.c +@@ -688,6 +688,49 @@ scroll_valuators_changed (ClutterInputDevice *device, + return retval; + } + ++static void ++clutter_device_manager_xi2_select_stage_events (ClutterDeviceManager *manager, ++ ClutterStage *stage) ++{ ++ ClutterBackendX11 *backend_x11; ++ ClutterStageX11 *stage_x11; ++ XIEventMask xi_event_mask; ++ unsigned char *mask; ++ int len; ++ ++ backend_x11 = CLUTTER_BACKEND_X11 (clutter_get_default_backend ()); ++ stage_x11 = CLUTTER_STAGE_X11 (_clutter_stage_get_window (stage)); ++ ++ len = XIMaskLen (XI_LASTEVENT); ++ mask = g_new0 (unsigned char, len); ++ ++ XISetMask (mask, XI_Motion); ++ XISetMask (mask, XI_ButtonPress); ++ XISetMask (mask, XI_ButtonRelease); ++ XISetMask (mask, XI_KeyPress); ++ XISetMask (mask, XI_KeyRelease); ++ XISetMask (mask, XI_Enter); ++ XISetMask (mask, XI_Leave); ++ ++#ifdef HAVE_XINPUT_2_2 ++ /* enable touch event support if we're running on XInput 2.2 */ ++ if (backend_x11->xi_minor >= 2) ++ { ++ XISetMask (mask, XI_TouchBegin); ++ XISetMask (mask, XI_TouchUpdate); ++ XISetMask (mask, XI_TouchEnd); ++ } ++#endif /* HAVE_XINPUT_2_2 */ ++ ++ xi_event_mask.deviceid = XIAllMasterDevices; ++ xi_event_mask.mask = mask; ++ xi_event_mask.mask_len = len; ++ ++ XISelectEvents (backend_x11->xdpy, stage_x11->xwin, &xi_event_mask, 1); ++ ++ g_free (mask); ++} ++ + static ClutterTranslateReturn + clutter_device_manager_xi2_translate_event (ClutterEventTranslator *translator, + gpointer native, +@@ -1483,6 +1526,7 @@ clutter_device_manager_xi2_class_init (ClutterDeviceManagerXI2Class *klass) + manager_class->get_devices = clutter_device_manager_xi2_get_devices; + manager_class->get_core_device = clutter_device_manager_xi2_get_core_device; + manager_class->get_device = clutter_device_manager_xi2_get_device; ++ manager_class->select_stage_events = clutter_device_manager_xi2_select_stage_events; + } + + static void +diff --git a/clutter/x11/clutter-input-device-xi2.c b/clutter/x11/clutter-input-device-xi2.c +index cd65b7b..b9e27a5 100644 +--- a/clutter/x11/clutter-input-device-xi2.c ++++ b/clutter/x11/clutter-input-device-xi2.c +@@ -54,53 +54,6 @@ G_DEFINE_TYPE (ClutterInputDeviceXI2, + CLUTTER_TYPE_INPUT_DEVICE); + + static void +-clutter_input_device_xi2_select_stage_events (ClutterInputDevice *device, +- ClutterStage *stage) +-{ +- ClutterInputDeviceXI2 *device_xi2 = CLUTTER_INPUT_DEVICE_XI2 (device); +- ClutterBackendX11 *backend_x11; +- ClutterStageX11 *stage_x11; +- XIEventMask xi_event_mask; +- unsigned char *mask; +- int len; +- +- backend_x11 = CLUTTER_BACKEND_X11 (device->backend); +- stage_x11 = CLUTTER_STAGE_X11 (_clutter_stage_get_window (stage)); +- +- len = XIMaskLen (XI_LASTEVENT); +- mask = g_new0 (unsigned char, len); +- +- XISetMask (mask, XI_Motion); +- XISetMask (mask, XI_ButtonPress); +- XISetMask (mask, XI_ButtonRelease); +- XISetMask (mask, XI_KeyPress); +- XISetMask (mask, XI_KeyRelease); +- XISetMask (mask, XI_Enter); +- XISetMask (mask, XI_Leave); +- +-#ifdef HAVE_XINPUT_2_2 +- /* enable touch event support if we're running on XInput 2.2 */ +- if (backend_x11->xi_minor >= 2) +- { +- XISetMask (mask, XI_TouchBegin); +- XISetMask (mask, XI_TouchUpdate); +- XISetMask (mask, XI_TouchEnd); +- } +-#endif /* HAVE_XINPUT_2_2 */ +- +- xi_event_mask.deviceid = device_xi2->device_id; +- xi_event_mask.mask = mask; +- xi_event_mask.mask_len = len; +- +- CLUTTER_NOTE (BACKEND, "Selecting device id '%d' events", +- device_xi2->device_id); +- +- XISelectEvents (backend_x11->xdpy, stage_x11->xwin, &xi_event_mask, 1); +- +- g_free (mask); +-} +- +-static void + clutter_input_device_xi2_constructed (GObject *gobject) + { + ClutterInputDeviceXI2 *device_xi2 = CLUTTER_INPUT_DEVICE_XI2 (gobject); +@@ -133,7 +86,6 @@ clutter_input_device_xi2_class_init (ClutterInputDeviceXI2Class *klass) + + gobject_class->constructed = clutter_input_device_xi2_constructed; + +- device_class->select_stage_events = clutter_input_device_xi2_select_stage_events; + device_class->keycode_to_evdev = clutter_input_device_xi2_keycode_to_evdev; + } + +-- +1.8.4.2 + diff --git a/SPECS/clutter.spec b/SPECS/clutter.spec index ebc2cbc..382960f 100644 --- a/SPECS/clutter.spec +++ b/SPECS/clutter.spec @@ -2,7 +2,7 @@ Name: clutter Version: 1.14.4 -Release: 3%{?dist} +Release: 9%{?dist} Summary: Open Source software library for creating rich graphical user interfaces Group: Development/Libraries @@ -13,6 +13,17 @@ Source0: http://download.gnome.org/sources/clutter/1.14/clutter-%{version} Patch0: 0001-cally-Use-a-weak-pointer-to-hold-the-key-focus-in-Ca.patch # https://bugzilla.gnome.org/show_bug.cgi?id=701974 Patch1: 0001-x11-trap-errors-when-calling-XIQueryDevice.patch +# https://bugzilla.redhat.com/show_bug.cgi?id=1039137 +Patch2: 0001-clutter-text-prevent-reset-of-user-set-font-descript.patch +# https://bugzilla.gnome.org/show_bug.cgi?id=703969 +Patch3: xi2-device-manager-cleanups.patch + +# https://bugzilla.gnome.org/show_bug.cgi?id=719367 +Patch4: Bind-constraints-Don-t-force-redraws-on-source-relay.patch +# https://bugzilla.gnome.org/show_bug.cgi?id=719368 +Patch5: Don-t-queue-redraws-when-reallocating-actor-that-hav.patch +# https://bugzilla.gnome.org/show_bug.cgi?id=719901 +Patch6: ClutterStageCogl-Ignore-a-clip-the-size-of-the-stage.patch BuildRequires: glib2-devel mesa-libGL-devel pkgconfig pango-devel BuildRequires: cairo-gobject-devel gdk-pixbuf2-devel atk-devel @@ -72,6 +83,11 @@ This package contains documentation for clutter. %setup -q %patch0 -p1 -b .cally_crash %patch1 -p1 -b .xi2-crash +%patch2 -p1 -b .font-switch +%patch3 -p1 -b .xi2-device-manager-cleanups +%patch4 -p1 -b .bind-contraints +%patch5 -p1 -b .unmoved-actors +%patch6 -p1 -b .stage-sized-clip %build (if ! test -x configure; then NOCONFIGURE=1 ./autogen.sh; CONFIGFLAGS=--enable-gtk-doc; fi; @@ -116,6 +132,25 @@ find %{buildroot} -name '*.la' -exec rm -f {} ';' %{_datadir}/gtk-doc/html/cally %changelog +* Tue Feb 11 2014 Owen Taylor - 1.14.4-9 +- Add upstream patches fixing problems that resulted in the entire + screen being redrawn too often with gnome shell. + Resolves: rhbz#1034941 + +* Fri Jan 24 2014 Daniel Mach - 1.14.4-8 +- Mass rebuild 2014-01-24 + +* Sat Jan 11 2014 Florian Müllner - 1.14.4-7 +- Backport device manager cleanups for pointer emulation for touch events + in mutter + Resolves: rhbz#1051029 + +* Mon Jan 6 2014 Rui Matos - 1.14.4-5 +- Resolves: rhbz#1039137 - gnome-shell text labels switch font temporarily until they redraw again + +* Fri Dec 27 2013 Daniel Mach - 1.14.4-4 +- Mass rebuild 2013-12-27 + * Sun Jun 23 2013 Matthias Clasen - 1.14.4-3 - Backport another upstream patch for gnome-shell crashes (#954054)