Browse Source

mutter package update

Signed-off-by: guibuilder_pel7x64builder0 <guibuilder@powerel.org>
master
guibuilder_pel7x64builder0 6 years ago
parent
commit
b8efaf5e63
  1. 37
      SOURCES/0001-Revert-build-Require-libgudev-232.patch
  2. 27
      SOURCES/0001-clutter-Only-reset-scroll-axes-on-slave-devices.patch
  3. 317
      SOURCES/0001-clutter-x11-Implement-keycode-lookup-from-keysyms-on.patch
  4. 30
      SOURCES/0001-monitor-manager-Consider-external-layout-before-defa.patch
  5. 505
      SOURCES/0001-monitor-manager-only-reuse-initial-config-if-monitor.patch
  6. 807
      SOURCES/0001-monitor-manager-xrandr-Force-an-update-when-resuming.patch
  7. 48
      SOURCES/0001-monitor-manager-xrandr-Work-around-spurious-hotplugs.patch
  8. 76
      SOURCES/0008-Add-support-for-quad-buffer-stereo.patch
  9. 71
      SOURCES/fix-crash-when-modal-closes-during-drag.patch
  10. 3006
      SOURCES/hw-cursor-on-demand-gnome-3-28.patch
  11. 79
      SPECS/mutter.spec

37
SOURCES/0001-Revert-build-Require-libgudev-232.patch

@ -1,19 +1,20 @@ @@ -1,19 +1,20 @@
From 23f4b91105c4fa9fa2231d2e1049728a6383cd65 Mon Sep 17 00:00:00 2001
From 6a807a31b5d762797850948761d66c1ab4fbfd7b Mon Sep 17 00:00:00 2001
From: Olivier Fourdan <ofourdan@redhat.com>
Date: Fri, 15 Sep 2017 09:39:18 +0200
Subject: [PATCH] Revert "build: Require libgudev >= 232"

This reverts commit 361bf847af82c7dca097302fe64c575079280c9c.
---
configure.ac | 4 ++--
src/backends/native/meta-launcher.c | 4 ++++
2 files changed, 6 insertions(+), 2 deletions(-)
configure.ac | 4 ++--
src/backends/native/meta-launcher.c | 2 ++
src/backends/native/meta-monitor-manager-kms.c | 3 +++
3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/configure.ac b/configure.ac
index 805707933..813ca008a 100644
index e6b2bf8..2fde187 100644
--- a/configure.ac
+++ b/configure.ac
@@ -225,10 +225,10 @@ AC_MSG_CHECKING([gudev])
@@ -227,10 +227,10 @@ AC_MSG_CHECKING([gudev])
if test x$with_gudev = xno ; then
AC_MSG_RESULT([disabled])
else
@ -27,20 +28,32 @@ index 805707933..813ca008a 100644 @@ -27,20 +28,32 @@ index 805707933..813ca008a 100644
else
AC_MSG_RESULT(no)
diff --git a/src/backends/native/meta-launcher.c b/src/backends/native/meta-launcher.c
index eb35f88be..90b4b98ba 100644
index 8b066c9..22ea2ad 100644
--- a/src/backends/native/meta-launcher.c
+++ b/src/backends/native/meta-launcher.c
@@ -49,6 +49,10 @@
@@ -46,6 +46,8 @@
#include "meta-cursor-renderer-native.h"
#include "meta-renderer-native.h"
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GUdevClient, g_object_unref)
+
struct _MetaLauncher
{
Login1Session *session_proxy;
diff --git a/src/backends/native/meta-monitor-manager-kms.c b/src/backends/native/meta-monitor-manager-kms.c
index 1a2eaec..2a13cdb 100644
--- a/src/backends/native/meta-monitor-manager-kms.c
+++ b/src/backends/native/meta-monitor-manager-kms.c
@@ -52,6 +52,9 @@
#define DRM_CARD_UDEV_DEVICE_TYPE "drm_minor"
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GUdevDevice, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GUdevClient, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GUdevEnumerator, g_object_unref)
+
struct _MetaLauncher
typedef struct
{
Login1Session *session_proxy;
GSource source;
--
2.13.5
1.8.3.1


27
SOURCES/0001-clutter-Only-reset-scroll-axes-on-slave-devices.patch

@ -0,0 +1,27 @@ @@ -0,0 +1,27 @@
From ee5b766580c702858bb10bab764a39f95a5b6432 Mon Sep 17 00:00:00 2001
From: Carlos Garnacho <carlosg@gnome.org>
Date: Wed, 13 Jun 2018 13:48:24 +0200
Subject: [PATCH] clutter: Only reset scroll axes on slave devices

As a plus, unknown source device IDs will just warn instead of crash.
---
clutter/clutter/x11/clutter-device-manager-xi2.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/clutter/clutter/x11/clutter-device-manager-xi2.c b/clutter/clutter/x11/clutter-device-manager-xi2.c
index 62f558380..ec7268ca8 100644
--- a/clutter/clutter/x11/clutter-device-manager-xi2.c
+++ b/clutter/clutter/x11/clutter-device-manager-xi2.c
@@ -1803,7 +1803,8 @@ clutter_device_manager_xi2_translate_event (ClutterEventTranslator *translator,
_clutter_input_device_set_stage (device, NULL);
}
- _clutter_input_device_reset_scroll_info (source_device);
+ if (clutter_input_device_get_device_mode (source_device) == CLUTTER_INPUT_MODE_SLAVE)
+ _clutter_input_device_reset_scroll_info (source_device);
clutter_event_set_device (event, device);
clutter_event_set_source_device (event, source_device);
--
2.14.3

317
SOURCES/0001-clutter-x11-Implement-keycode-lookup-from-keysyms-on.patch

@ -0,0 +1,317 @@ @@ -0,0 +1,317 @@
From 8dfcfa0607754caab5032532ccc9d97b4393708e Mon Sep 17 00:00:00 2001
From: Carlos Garnacho <carlosg@gnome.org>
Date: Fri, 29 Jun 2018 14:31:23 +0200
Subject: [PATCH] clutter/x11: Implement keycode lookup from keysyms on virtual
key devices

Unfortunately XKeysymToKeycode() falls short in that it coalesces keysyms
into keycodes pertaining to the first level (i.e. lowercase). Add a
ClutterKeymapX11 method (much alike its GdkKeymap counterpart) to look up
all matches for the given keysym.

Two other helper methods have been added so the virtual device can fetch
the current keyboard group, and latch modifiers for key emission. Combining
all this, the virtual device is now able to handle keycodes in further
levels.

Closes: https://gitlab.gnome.org/GNOME/gnome-shell/issues/135

(cherry picked from commit 85284acb000ddc70afcf716b6c198b4b5bf5741e)
---
clutter/clutter/x11/clutter-keymap-x11.c | 178 +++++++++++++++++-
clutter/clutter/x11/clutter-keymap-x11.h | 8 +
.../x11/clutter-virtual-input-device-x11.c | 22 ++-
3 files changed, 204 insertions(+), 4 deletions(-)

diff --git a/clutter/clutter/x11/clutter-keymap-x11.c b/clutter/clutter/x11/clutter-keymap-x11.c
index 914e31434..c34e676a4 100644
--- a/clutter/clutter/x11/clutter-keymap-x11.c
+++ b/clutter/clutter/x11/clutter-keymap-x11.c
@@ -38,6 +38,14 @@
typedef struct _ClutterKeymapX11Class ClutterKeymapX11Class;
typedef struct _DirectionCacheEntry DirectionCacheEntry;
+typedef struct _ClutterKeymapKey ClutterKeymapKey;
+
+struct _ClutterKeymapKey
+{
+ guint keycode;
+ guint group;
+ guint level;
+};
struct _DirectionCacheEntry
{
@@ -59,6 +67,7 @@ struct _ClutterKeymapX11
ClutterModifierType num_lock_mask;
ClutterModifierType scroll_lock_mask;
+ ClutterModifierType level3_shift_mask;
PangoDirection current_direction;
@@ -69,6 +78,7 @@ struct _ClutterKeymapX11
Atom current_group_atom;
guint current_cache_serial;
DirectionCacheEntry group_direction_cache[4];
+ int current_group;
#endif
guint caps_lock_state : 1;
@@ -198,6 +208,9 @@ get_xkb (ClutterKeymapX11 *keymap_x11)
if (keymap_x11->scroll_lock_mask == 0)
keymap_x11->scroll_lock_mask = XkbKeysymToModifiers (backend_x11->xdpy,
XK_Scroll_Lock);
+ if (keymap_x11->level3_shift_mask == 0)
+ keymap_x11->level3_shift_mask = XkbKeysymToModifiers (backend_x11->xdpy,
+ XK_ISO_Level3_Shift);
return keymap_x11->xkb_desc;
}
@@ -469,6 +482,7 @@ static void
clutter_keymap_x11_init (ClutterKeymapX11 *keymap)
{
keymap->current_direction = PANGO_DIRECTION_NEUTRAL;
+ keymap->current_group = -1;
}
static ClutterTranslateReturn
@@ -498,7 +512,8 @@ clutter_keymap_x11_translate_event (ClutterEventTranslator *translator,
{
case XkbStateNotify:
CLUTTER_NOTE (EVENT, "Updating keyboard state");
- update_direction (keymap_x11, XkbStateGroup (&xkb_event->state));
+ keymap_x11->current_group = XkbStateGroup (&xkb_event->state);
+ update_direction (keymap_x11, keymap_x11->current_group);
update_locked_mods (keymap_x11, xkb_event->state.locked_mods);
retval = CLUTTER_TRANSLATE_REMOVE;
break;
@@ -665,3 +680,164 @@ _clutter_keymap_x11_get_direction (ClutterKeymapX11 *keymap)
#endif
return PANGO_DIRECTION_NEUTRAL;
}
+
+static gboolean
+clutter_keymap_x11_get_entries_for_keyval (ClutterKeymapX11 *keymap_x11,
+ guint keyval,
+ ClutterKeymapKey **keys,
+ gint *n_keys)
+{
+#ifdef HAVE_XKB
+ if (CLUTTER_BACKEND_X11 (keymap_x11->backend)->use_xkb)
+ {
+ XkbDescRec *xkb = get_xkb (keymap_x11);
+ GArray *retval;
+ gint keycode;
+
+ keycode = keymap_x11->min_keycode;
+ retval = g_array_new (FALSE, FALSE, sizeof (ClutterKeymapKey));
+
+ while (keycode <= keymap_x11->max_keycode)
+ {
+ gint max_shift_levels = XkbKeyGroupsWidth (xkb, keycode);
+ gint group = 0;
+ gint level = 0;
+ gint total_syms = XkbKeyNumSyms (xkb, keycode);
+ gint i = 0;
+ KeySym *entry;
+
+ /* entry is an array with all syms for group 0, all
+ * syms for group 1, etc. and for each group the
+ * shift level syms are in order
+ */
+ entry = XkbKeySymsPtr (xkb, keycode);
+
+ while (i < total_syms)
+ {
+ g_assert (i == (group * max_shift_levels + level));
+
+ if (entry[i] == keyval)
+ {
+ ClutterKeymapKey key;
+
+ key.keycode = keycode;
+ key.group = group;
+ key.level = level;
+
+ g_array_append_val (retval, key);
+
+ g_assert (XkbKeySymEntry (xkb, keycode, level, group) ==
+ keyval);
+ }
+
+ ++level;
+
+ if (level == max_shift_levels)
+ {
+ level = 0;
+ ++group;
+ }
+
+ ++i;
+ }
+
+ ++keycode;
+ }
+
+ if (retval->len > 0)
+ {
+ *keys = (ClutterKeymapKey*) retval->data;
+ *n_keys = retval->len;
+ }
+ else
+ {
+ *keys = NULL;
+ *n_keys = 0;
+ }
+
+ g_array_free (retval, retval->len > 0 ? FALSE : TRUE);
+
+ return *n_keys > 0;
+ }
+ else
+#endif
+ {
+ return FALSE;
+ }
+}
+
+void
+clutter_keymap_x11_latch_modifiers (ClutterKeymapX11 *keymap_x11,
+ uint32_t level,
+ gboolean enable)
+{
+#ifdef HAVE_XKB
+ ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend);
+ uint32_t modifiers[] = {
+ 0,
+ ShiftMask,
+ keymap_x11->level3_shift_mask,
+ keymap_x11->level3_shift_mask | ShiftMask,
+ };
+ uint32_t value = 0;
+
+ if (!backend_x11->use_xkb)
+ return;
+
+ level = CLAMP (level, 0, G_N_ELEMENTS (modifiers) - 1);
+
+ if (enable)
+ value = modifiers[level];
+ else
+ value = 0;
+
+ XkbLatchModifiers (clutter_x11_get_default_display (),
+ XkbUseCoreKbd, modifiers[level],
+ value);
+#endif
+}
+
+static uint32_t
+clutter_keymap_x11_get_current_group (ClutterKeymapX11 *keymap_x11)
+{
+ ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend);
+ XkbStateRec state_rec;
+
+ if (keymap_x11->current_group >= 0)
+ return keymap_x11->current_group;
+
+ XkbGetState (backend_x11->xdpy, XkbUseCoreKbd, &state_rec);
+ return XkbStateGroup (&state_rec);
+}
+
+gboolean
+clutter_keymap_x11_keycode_for_keyval (ClutterKeymapX11 *keymap_x11,
+ guint keyval,
+ guint *keycode_out,
+ guint *level_out)
+{
+ ClutterKeymapKey *keys;
+ gint i, n_keys, group;
+ gboolean found = FALSE;
+
+ g_return_val_if_fail (keycode_out != NULL, FALSE);
+ g_return_val_if_fail (level_out != NULL, FALSE);
+
+ group = clutter_keymap_x11_get_current_group (keymap_x11);
+
+ if (!clutter_keymap_x11_get_entries_for_keyval (keymap_x11, keyval, &keys, &n_keys))
+ return FALSE;
+
+ for (i = 0; i < n_keys && !found; i++)
+ {
+ if (keys[i].group == group)
+ {
+ *keycode_out = keys[i].keycode;
+ *level_out = keys[i].level;
+ found = TRUE;
+ }
+ }
+
+ g_free (keys);
+ return found;
+}
diff --git a/clutter/clutter/x11/clutter-keymap-x11.h b/clutter/clutter/x11/clutter-keymap-x11.h
index ad673a2a7..4b5b403c8 100644
--- a/clutter/clutter/x11/clutter-keymap-x11.h
+++ b/clutter/clutter/x11/clutter-keymap-x11.h
@@ -51,6 +51,14 @@ gboolean _clutter_keymap_x11_get_is_modifier (ClutterKeymapX11 *keymap,
PangoDirection _clutter_keymap_x11_get_direction (ClutterKeymapX11 *keymap);
+gboolean clutter_keymap_x11_keycode_for_keyval (ClutterKeymapX11 *keymap_x11,
+ guint keyval,
+ guint *keycode_out,
+ guint *level_out);
+void clutter_keymap_x11_latch_modifiers (ClutterKeymapX11 *keymap_x11,
+ uint32_t level,
+ gboolean enable);
+
G_END_DECLS
#endif /* __CLUTTER_KEYMAP_X11_H__ */
diff --git a/clutter/clutter/x11/clutter-virtual-input-device-x11.c b/clutter/clutter/x11/clutter-virtual-input-device-x11.c
index 416c944b3..b86ded0d0 100644
--- a/clutter/clutter/x11/clutter-virtual-input-device-x11.c
+++ b/clutter/clutter/x11/clutter-virtual-input-device-x11.c
@@ -32,6 +32,8 @@
#include "clutter-virtual-input-device.h"
#include "x11/clutter-virtual-input-device-x11.h"
+#include "x11/clutter-backend-x11.h"
+#include "x11/clutter-keymap-x11.h"
struct _ClutterVirtualInputDeviceX11
{
@@ -135,11 +137,25 @@ clutter_virtual_input_device_x11_notify_keyval (ClutterVirtualInputDevice *virtu
uint32_t keyval,
ClutterKeyState key_state)
{
- KeyCode keycode;
+ ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (clutter_get_default_backend ());
+ ClutterKeymapX11 *keymap = backend_x11->keymap;
+ uint32_t keycode, level;
+
+ if (!clutter_keymap_x11_keycode_for_keyval (keymap, keyval, &keycode, &level))
+ {
+ g_warning ("No keycode found for keyval %x in current group", keyval);
+ return;
+ }
+
+ if (key_state == CLUTTER_KEY_STATE_PRESSED)
+ clutter_keymap_x11_latch_modifiers (keymap, level, TRUE);
- keycode = XKeysymToKeycode (clutter_x11_get_default_display (), keyval);
XTestFakeKeyEvent (clutter_x11_get_default_display (),
- keycode, key_state == CLUTTER_KEY_STATE_PRESSED, 0);
+ (KeyCode) keycode,
+ key_state == CLUTTER_KEY_STATE_PRESSED, 0);
+
+ if (key_state == CLUTTER_KEY_STATE_RELEASED)
+ clutter_keymap_x11_latch_modifiers (keymap, level, FALSE);
}
static void
--
2.19.0.rc0

30
SOURCES/0001-monitor-manager-Consider-external-layout-before-defa.patch

@ -1,4 +1,4 @@ @@ -1,4 +1,4 @@
From 679644180338527648d7856640c2021b4f4daf30 Mon Sep 17 00:00:00 2001
From 648f1ce9350fcab0ebaecccb115b5021c632e7b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Florian=20M=C3=BCllner?= <fmuellner@gnome.org>
Date: Thu, 28 Jan 2016 15:26:33 +0100
Subject: [PATCH] monitor-manager: Consider external layout before default
@ -11,16 +11,16 @@ which is not desirable. Instead, base the initial configuration on @@ -11,16 +11,16 @@ which is not desirable. Instead, base the initial configuration on
the existing layout if it passes some sanity checks before falling
back to the default linear config.
---
src/backends/meta-monitor-config-manager.c | 71 ++++++++++++++++++++++++++++++
src/backends/meta-monitor-config-manager.c | 75 ++++++++++++++++++++++
src/backends/meta-monitor-config-manager.h | 1 +
src/backends/meta-monitor-manager.c | 19 ++++++++
3 files changed, 91 insertions(+)
3 files changed, 97 insertions(+)

diff --git a/src/backends/meta-monitor-config-manager.c b/src/backends/meta-monitor-config-manager.c
index cdc9fb775..2fe620767 100644
index 197892bf2..ae988f64a 100644
--- a/src/backends/meta-monitor-config-manager.c
+++ b/src/backends/meta-monitor-config-manager.c
@@ -558,6 +558,77 @@ create_preferred_logical_monitor_config (MetaMonitorManager *monitor_ma
@@ -559,6 +559,83 @@ create_preferred_logical_monitor_config (MetaMonitorManager *monitor_ma
return logical_monitor_config;
}
@ -31,12 +31,14 @@ index cdc9fb775..2fe620767 100644 @@ -31,12 +31,14 @@ index cdc9fb775..2fe620767 100644
+ MetaLogicalMonitorLayoutMode layout_mode)
+{
+ MetaOutput *output;
+ MetaCrtc *crtc;
+
+ output = meta_monitor_get_main_output (monitor);
+ crtc = meta_output_get_assigned_crtc (output);
+ return create_preferred_logical_monitor_config (monitor_manager,
+ monitor,
+ output->crtc->rect.x,
+ output->crtc->rect.y,
+ crtc->rect.x,
+ crtc->rect.y,
+ primary_logical_monitor_config,
+ layout_mode);
+}
@ -92,14 +94,18 @@ index cdc9fb775..2fe620767 100644 @@ -92,14 +94,18 @@ index cdc9fb775..2fe620767 100644
+ logical_monitor_configs = g_list_append (logical_monitor_configs,
+ logical_monitor_config);
+ }
+ return NULL;
+
+ return meta_monitors_config_new (monitor_manager,
+ logical_monitor_configs,
+ layout_mode,
+ META_MONITORS_CONFIG_FLAG_NONE);
+}
+
MetaMonitorsConfig *
meta_monitor_config_manager_create_linear (MetaMonitorConfigManager *config_manager)
{
diff --git a/src/backends/meta-monitor-config-manager.h b/src/backends/meta-monitor-config-manager.h
index b99cdaba2..516909dd7 100644
index 269d8e1b7..c36df38e6 100644
--- a/src/backends/meta-monitor-config-manager.h
+++ b/src/backends/meta-monitor-config-manager.h
@@ -87,6 +87,7 @@ gboolean meta_monitor_config_manager_assign (MetaMonitorManager *manager,
@ -111,10 +117,10 @@ index b99cdaba2..516909dd7 100644 @@ -111,10 +117,10 @@ index b99cdaba2..516909dd7 100644
MetaMonitorsConfig * meta_monitor_config_manager_create_fallback (MetaMonitorConfigManager *config_manager);
diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c
index f2ad3f3d0..8b548fd68 100644
index 0b5e54c48..263e93941 100644
--- a/src/backends/meta-monitor-manager.c
+++ b/src/backends/meta-monitor-manager.c
@@ -553,6 +553,25 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
@@ -576,6 +576,25 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
g_clear_object (&config);
}
@ -141,5 +147,5 @@ index f2ad3f3d0..8b548fd68 100644 @@ -141,5 +147,5 @@ index f2ad3f3d0..8b548fd68 100644
if (config)
{
--
2.14.2
2.17.1


505
SOURCES/0001-monitor-manager-only-reuse-initial-config-if-monitor.patch

@ -0,0 +1,505 @@ @@ -0,0 +1,505 @@
From 0cc90f343f4caadb5c4279623a0811c378715a09 Mon Sep 17 00:00:00 2001
From: rpm-build <rpm-build>
Date: Tue, 11 Sep 2018 10:19:44 -0400
Subject: [PATCH] monitor-manager: only reuse initial-config if monitor
topology matches startup

Right now we try to apply the current monitor config when a new
monitor is attached. The current config obviously doesn't include the
new monitor, so the new monitor isn't lit up.

The only reason we apply the current config at all is to handle the
startup case: We want to reuse the config set in Xorg when first
logging in.

This commit changes the code to look at the *initial config* instead
of the current config, and only if the new monitor topology matches
the start up topology.
---
src/backends/meta-monitor-config-manager.c | 20 +++++++++++++++-----
src/backends/meta-monitor-config-manager.h | 2 +-
src/backends/meta-monitor-manager.c | 16 +++++++++++++++-
3 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/backends/meta-monitor-config-manager.c b/src/backends/meta-monitor-config-manager.c
index 585ee7034..1ad342a44 100644
--- a/src/backends/meta-monitor-config-manager.c
+++ b/src/backends/meta-monitor-config-manager.c
@@ -13,60 +13,61 @@
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include "config.h"
#include "backends/meta-monitor-config-manager.h"
#include "backends/meta-monitor-config-migration.h"
#include "backends/meta-monitor-config-store.h"
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-output.h"
#include "core/boxes-private.h"
#define CONFIG_HISTORY_MAX_SIZE 3
struct _MetaMonitorConfigManager
{
GObject parent;
MetaMonitorManager *monitor_manager;
MetaMonitorConfigStore *config_store;
MetaMonitorsConfig *current_config;
+ MetaMonitorsConfig *initial_config;
GQueue config_history;
};
G_DEFINE_TYPE (MetaMonitorConfigManager, meta_monitor_config_manager,
G_TYPE_OBJECT)
G_DEFINE_TYPE (MetaMonitorsConfig, meta_monitors_config,
G_TYPE_OBJECT)
static void
meta_crtc_info_free (MetaCrtcInfo *info);
static void
meta_output_info_free (MetaOutputInfo *info);
MetaMonitorConfigManager *
meta_monitor_config_manager_new (MetaMonitorManager *monitor_manager)
{
MetaMonitorConfigManager *config_manager;
config_manager = g_object_new (META_TYPE_MONITOR_CONFIG_MANAGER, NULL);
config_manager->monitor_manager = monitor_manager;
config_manager->config_store =
meta_monitor_config_store_new (monitor_manager);
return config_manager;
}
MetaMonitorConfigStore *
meta_monitor_config_manager_get_store (MetaMonitorConfigManager *config_manager)
@@ -552,115 +553,123 @@ create_preferred_logical_monitor_config (MetaMonitorManager *monitor_ma
.width = width,
.height = height
},
.scale = scale,
.monitor_configs = g_list_append (NULL, monitor_config)
};
return logical_monitor_config;
}
static MetaLogicalMonitorConfig *
create_logical_monitor_config_from_output (MetaMonitorManager *monitor_manager,
MetaMonitor *monitor,
MetaLogicalMonitorConfig *primary_logical_monitor_config,
MetaLogicalMonitorLayoutMode layout_mode)
{
MetaOutput *output;
MetaCrtc *crtc;
output = meta_monitor_get_main_output (monitor);
crtc = meta_output_get_assigned_crtc (output);
return create_preferred_logical_monitor_config (monitor_manager,
monitor,
crtc->rect.x,
crtc->rect.y,
primary_logical_monitor_config,
layout_mode);
}
MetaMonitorsConfig *
-meta_monitor_config_manager_create_current (MetaMonitorConfigManager *config_manager)
+meta_monitor_config_manager_create_initial (MetaMonitorConfigManager *config_manager)
{
MetaMonitorManager *monitor_manager = config_manager->monitor_manager;
+ MetaMonitorsConfig *initial_config;
GList *logical_monitor_configs;
MetaMonitor *primary_monitor;
MetaLogicalMonitorLayoutMode layout_mode;
MetaLogicalMonitorConfig *primary_logical_monitor_config;
GList *monitors;
GList *l;
+ if (config_manager->initial_config != NULL)
+ return g_object_ref (config_manager->initial_config);
+
if (meta_monitor_config_store_get_config_count (config_manager->config_store) > 0)
return NULL;
primary_monitor = find_primary_monitor (monitor_manager);
if (!primary_monitor || !meta_monitor_is_active (primary_monitor))
return NULL;
layout_mode = meta_monitor_manager_get_default_layout_mode (monitor_manager);
primary_logical_monitor_config =
create_logical_monitor_config_from_output (monitor_manager,
primary_monitor,
NULL,
layout_mode);
primary_logical_monitor_config->is_primary = TRUE;
logical_monitor_configs = g_list_append (NULL,
primary_logical_monitor_config);
monitors = meta_monitor_manager_get_monitors (monitor_manager);
for (l = monitors; l; l = l->next)
{
MetaMonitor *monitor = l->data;
MetaLogicalMonitorConfig *logical_monitor_config;
if (monitor == primary_monitor)
continue;
if (!meta_monitor_is_active (monitor))
continue;
logical_monitor_config =
create_logical_monitor_config_from_output (monitor_manager,
monitor,
primary_logical_monitor_config,
layout_mode);
logical_monitor_configs = g_list_append (logical_monitor_configs,
logical_monitor_config);
}
- return meta_monitors_config_new (monitor_manager,
- logical_monitor_configs,
- layout_mode,
- META_MONITORS_CONFIG_FLAG_NONE);
+ initial_config = meta_monitors_config_new (monitor_manager,
+ logical_monitor_configs,
+ layout_mode,
+ META_MONITORS_CONFIG_FLAG_NONE);
+
+ config_manager->initial_config = g_object_ref (initial_config);
+
+ return initial_config;
}
MetaMonitorsConfig *
meta_monitor_config_manager_create_linear (MetaMonitorConfigManager *config_manager)
{
MetaMonitorManager *monitor_manager = config_manager->monitor_manager;
GList *logical_monitor_configs;
MetaMonitor *primary_monitor;
MetaLogicalMonitorLayoutMode layout_mode;
MetaLogicalMonitorConfig *primary_logical_monitor_config;
int x;
GList *monitors;
GList *l;
primary_monitor = find_primary_monitor (monitor_manager);
if (!primary_monitor)
return NULL;
layout_mode = meta_monitor_manager_get_default_layout_mode (monitor_manager);
primary_logical_monitor_config =
create_preferred_logical_monitor_config (monitor_manager,
primary_monitor,
0, 0,
NULL,
layout_mode);
primary_logical_monitor_config->is_primary = TRUE;
logical_monitor_configs = g_list_append (NULL,
primary_logical_monitor_config);
@@ -1135,60 +1144,61 @@ meta_monitor_config_manager_get_current (MetaMonitorConfigManager *config_manage
{
return config_manager->current_config;
}
MetaMonitorsConfig *
meta_monitor_config_manager_pop_previous (MetaMonitorConfigManager *config_manager)
{
return g_queue_pop_head (&config_manager->config_history);
}
MetaMonitorsConfig *
meta_monitor_config_manager_get_previous (MetaMonitorConfigManager *config_manager)
{
return g_queue_peek_head (&config_manager->config_history);
}
void
meta_monitor_config_manager_clear_history (MetaMonitorConfigManager *config_manager)
{
g_queue_foreach (&config_manager->config_history, (GFunc) g_object_unref, NULL);
g_queue_clear (&config_manager->config_history);
}
static void
meta_monitor_config_manager_dispose (GObject *object)
{
MetaMonitorConfigManager *config_manager =
META_MONITOR_CONFIG_MANAGER (object);
g_clear_object (&config_manager->current_config);
+ g_clear_object (&config_manager->initial_config);
meta_monitor_config_manager_clear_history (config_manager);
G_OBJECT_CLASS (meta_monitor_config_manager_parent_class)->dispose (object);
}
static void
meta_monitor_config_manager_init (MetaMonitorConfigManager *config_manager)
{
g_queue_init (&config_manager->config_history);
}
static void
meta_monitor_config_manager_class_init (MetaMonitorConfigManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = meta_monitor_config_manager_dispose;
}
void
meta_monitor_config_free (MetaMonitorConfig *monitor_config)
{
meta_monitor_spec_free (monitor_config->monitor_spec);
g_free (monitor_config->mode_spec);
g_free (monitor_config);
}
void
meta_logical_monitor_config_free (MetaLogicalMonitorConfig *logical_monitor_config)
{
diff --git a/src/backends/meta-monitor-config-manager.h b/src/backends/meta-monitor-config-manager.h
index c36df38e6..29ef8f8ce 100644
--- a/src/backends/meta-monitor-config-manager.h
+++ b/src/backends/meta-monitor-config-manager.h
@@ -60,61 +60,61 @@ typedef enum _MetaMonitorsConfigFlag
struct _MetaMonitorsConfig
{
GObject parent;
MetaMonitorsConfigKey *key;
GList *logical_monitor_configs;
GList *disabled_monitor_specs;
MetaMonitorsConfigFlag flags;
MetaLogicalMonitorLayoutMode layout_mode;
};
#define META_TYPE_MONITORS_CONFIG (meta_monitors_config_get_type ())
G_DECLARE_FINAL_TYPE (MetaMonitorsConfig, meta_monitors_config,
META, MONITORS_CONFIG, GObject)
MetaMonitorConfigManager * meta_monitor_config_manager_new (MetaMonitorManager *monitor_manager);
MetaMonitorConfigStore * meta_monitor_config_manager_get_store (MetaMonitorConfigManager *config_manager);
gboolean meta_monitor_config_manager_assign (MetaMonitorManager *manager,
MetaMonitorsConfig *config,
GPtrArray **crtc_infos,
GPtrArray **output_infos,
GError **error);
MetaMonitorsConfig * meta_monitor_config_manager_get_stored (MetaMonitorConfigManager *config_manager);
-MetaMonitorsConfig * meta_monitor_config_manager_create_current (MetaMonitorConfigManager *config_manager);
+MetaMonitorsConfig * meta_monitor_config_manager_create_initial (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_create_linear (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_create_fallback (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_create_suggested (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_create_for_orientation (MetaMonitorConfigManager *config_manager,
MetaMonitorTransform transform);
MetaMonitorsConfig * meta_monitor_config_manager_create_for_rotate_monitor (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_create_for_switch_config (MetaMonitorConfigManager *config_manager,
MetaMonitorSwitchConfigType config_type);
void meta_monitor_config_manager_set_current (MetaMonitorConfigManager *config_manager,
MetaMonitorsConfig *config);
MetaMonitorsConfig * meta_monitor_config_manager_get_current (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_pop_previous (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitor_config_manager_get_previous (MetaMonitorConfigManager *config_manager);
void meta_monitor_config_manager_clear_history (MetaMonitorConfigManager *config_manager);
void meta_monitor_config_manager_save_current (MetaMonitorConfigManager *config_manager);
MetaMonitorsConfig * meta_monitors_config_new_full (GList *logical_monitor_configs,
GList *disabled_monitors,
MetaLogicalMonitorLayoutMode layout_mode,
diff --git a/src/backends/meta-monitor-manager.c b/src/backends/meta-monitor-manager.c
index 4503eb841..f7ada0136 100644
--- a/src/backends/meta-monitor-manager.c
+++ b/src/backends/meta-monitor-manager.c
@@ -469,73 +469,87 @@ meta_monitor_manager_apply_monitors_config (MetaMonitorManager *manager,
return TRUE;
}
gboolean
meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager)
{
GList *l;
for (l = manager->gpus; l; l = l->next)
{
MetaGpu *gpu = l->data;
if (meta_gpu_has_hotplug_mode_update (gpu))
return TRUE;
}
return FALSE;
}
static gboolean
should_use_stored_config (MetaMonitorManager *manager)
{
return (manager->in_init ||
!meta_monitor_manager_has_hotplug_mode_update (manager));
}
MetaMonitorsConfig *
meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
{
+ g_autoptr (MetaMonitorsConfig) initial_config = NULL;
MetaMonitorsConfig *config = NULL;
GError *error = NULL;
gboolean use_stored_config;
+ MetaMonitorsConfigKey *current_state_key;
MetaMonitorsConfigMethod method;
MetaMonitorsConfigMethod fallback_method =
META_MONITORS_CONFIG_METHOD_TEMPORARY;
use_stored_config = should_use_stored_config (manager);
if (use_stored_config)
method = META_MONITORS_CONFIG_METHOD_PERSISTENT;
else
method = META_MONITORS_CONFIG_METHOD_TEMPORARY;
+ initial_config = meta_monitor_config_manager_create_initial (manager->config_manager);
+
+ if (initial_config)
+ {
+ current_state_key = meta_create_monitors_config_key_for_current_state (manager);
+
+ /* don't ever reuse initial configuration, if the monitor topology changed
+ */
+ if (current_state_key && !meta_monitors_config_key_equal (current_state_key, initial_config->key))
+ g_clear_object (&initial_config);
+ }
+
if (use_stored_config)
{
config = meta_monitor_config_manager_get_stored (manager->config_manager);
if (config)
{
if (!meta_monitor_manager_apply_monitors_config (manager,
config,
method,
&error))
{
config = NULL;
g_warning ("Failed to use stored monitor configuration: %s",
error->message);
g_clear_error (&error);
}
else
{
g_object_ref (config);
goto done;
}
}
}
config = meta_monitor_config_manager_create_suggested (manager->config_manager);
if (config)
{
if (!meta_monitor_manager_apply_monitors_config (manager,
config,
method,
&error))
@@ -549,61 +563,61 @@ meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
{
goto done;
}
}
config = meta_monitor_config_manager_get_previous (manager->config_manager);
if (config)
{
config = g_object_ref (config);
if (meta_monitor_manager_is_config_complete (manager, config))
{
if (!meta_monitor_manager_apply_monitors_config (manager,
config,
method,
&error))
{
g_warning ("Failed to use suggested monitor configuration: %s",
error->message);
g_clear_error (&error);
}
else
{
goto done;
}
}
g_clear_object (&config);
}
- config = meta_monitor_config_manager_create_current (manager->config_manager);
+ config = g_steal_pointer (&initial_config);
if (config)
{
if (!meta_monitor_manager_apply_monitors_config (manager,
config,
method,
&error))
{
g_clear_object (&config);
g_warning ("Failed to use current monitor configuration: %s",
error->message);
g_clear_error (&error);
}
else
{
goto done;
}
}
config = meta_monitor_config_manager_create_linear (manager->config_manager);
if (config)
{
if (!meta_monitor_manager_apply_monitors_config (manager,
config,
method,
&error))
{
g_clear_object (&config);
g_warning ("Failed to use linear monitor configuration: %s",
error->message);
g_clear_error (&error);
--
2.17.1

807
SOURCES/0001-monitor-manager-xrandr-Force-an-update-when-resuming.patch

@ -1,107 +1,526 @@ @@ -1,107 +1,526 @@
From ed7cad0561b79e68ddd91f0e12042087199676ea Mon Sep 17 00:00:00 2001
From 100795c2729305f919ff9611c877ea3e74d528b7 Mon Sep 17 00:00:00 2001
From: Rui Matos <tiagomatos@gmail.com>
Date: Sun, 25 Oct 2015 16:14:58 +0100
Subject: [PATCH 3/8] monitor-manager-xrandr: Force an update when resuming
from suspend
Date: Mon, 4 Jun 2018 16:35:04 -0400
Subject: [PATCH] monitor-manager-xrandr: Force an update when resuming from
suspend

The stack below us isn't as reliable as we'd like and in some cases
doesn't generate RRScreenChangeNotify events when e.g. resuming a
laptop on a dock, meaning that we'd miss newly attached outputs.
---
src/backends/x11/meta-monitor-manager-xrandr.c | 188 ++++++++++++++++++-------
1 file changed, 137 insertions(+), 51 deletions(-)
src/backends/meta-gpu.c | 7 ++
src/backends/meta-gpu.h | 2 +
src/backends/x11/meta-gpu-xrandr.c | 26 ++++-
.../x11/meta-monitor-manager-xrandr.c | 96 +++++++++++++++++--
4 files changed, 121 insertions(+), 10 deletions(-)

diff --git a/src/backends/x11/meta-monitor-manager-xrandr.c b/src/backends/x11/meta-monitor-manager-xrandr.c
index 8d1bdfb69..d451fcccc 100644
--- a/src/backends/x11/meta-monitor-manager-xrandr.c
+++ b/src/backends/x11/meta-monitor-manager-xrandr.c
@@ -61,6 +61,11 @@ struct _MetaMonitorManagerXrandr
XRRScreenResources *resources;
int rr_event_base;
int rr_error_base;
+
+ guint logind_watch_id;
+ guint logind_signal_sub_id;
+
+ gboolean need_hardware_poll;
gboolean has_randr15;
diff --git a/src/backends/meta-gpu.c b/src/backends/meta-gpu.c
index 3577391e5..946f72387 100644
--- a/src/backends/meta-gpu.c
+++ b/src/backends/meta-gpu.c
@@ -37,60 +37,67 @@ enum
static GParamSpec *obj_props[PROP_LAST];
xcb_timestamp_t last_xrandr_set_timestamp;
@@ -787,8 +792,15 @@ meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
manager->screen_width = WidthOfScreen (screen);
manager->screen_height = HeightOfScreen (screen);
typedef struct _MetaGpuPrivate
{
MetaMonitorManager *monitor_manager;
- resources = XRRGetScreenResourcesCurrent (manager_xrandr->xdisplay,
- DefaultRootWindow (manager_xrandr->xdisplay));
+ if (manager_xrandr->need_hardware_poll)
+ {
+ resources = XRRGetScreenResources (manager_xrandr->xdisplay,
+ DefaultRootWindow (manager_xrandr->xdisplay));
+ manager_xrandr->need_hardware_poll = FALSE;
+ }
+ else
+ resources = XRRGetScreenResourcesCurrent (manager_xrandr->xdisplay,
+ DefaultRootWindow (manager_xrandr->xdisplay));
if (!resources)
return;
GList *outputs;
GList *crtcs;
GList *modes;
} MetaGpuPrivate;
@@ -1910,6 +1922,115 @@ meta_monitor_manager_xrandr_get_default_layout_mode (MetaMonitorManager *manager
return META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
G_DEFINE_TYPE_WITH_PRIVATE (MetaGpu, meta_gpu, G_TYPE_OBJECT)
gboolean
meta_gpu_has_hotplug_mode_update (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
GList *l;
for (l = priv->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->hotplug_mode_update)
return TRUE;
}
return FALSE;
}
+static gboolean
+is_xvnc (MetaMonitorManager *manager)
+void
+meta_gpu_poll_hardware (MetaGpu *gpu)
+{
+ unsigned int i;
+
+ for (i = 0; i < manager->n_outputs; ++i)
+ if (g_str_has_prefix (manager->outputs[i].name, "VNC-"))
+ return TRUE;
+
+ return FALSE;
+ if (META_GPU_GET_CLASS (gpu)->poll_hardware)
+ META_GPU_GET_CLASS (gpu)->poll_hardware (gpu);
+}
+
gboolean
meta_gpu_read_current (MetaGpu *gpu,
GError **error)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
gboolean ret;
GList *old_outputs;
GList *old_crtcs;
GList *old_modes;
/* TODO: Get rid of this when objects incref:s what they need instead */
old_outputs = priv->outputs;
old_crtcs = priv->crtcs;
old_modes = priv->modes;
ret = META_GPU_GET_CLASS (gpu)->read_current (gpu, error);
g_list_free_full (old_outputs, g_object_unref);
g_list_free_full (old_modes, g_object_unref);
g_list_free_full (old_crtcs, g_object_unref);
return ret;
}
MetaMonitorManager *
meta_gpu_get_monitor_manager (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
return priv->monitor_manager;
diff --git a/src/backends/meta-gpu.h b/src/backends/meta-gpu.h
index 4badcbd26..3cec8e5b0 100644
--- a/src/backends/meta-gpu.h
+++ b/src/backends/meta-gpu.h
@@ -8,59 +8,61 @@
* published by the Free Software Foundation; either version 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef META_GPU_H
#define META_GPU_H
#include <glib-object.h>
#include "backends/meta-monitor-manager-private.h"
#define META_TYPE_GPU (meta_gpu_get_type ())
G_DECLARE_DERIVABLE_TYPE (MetaGpu, meta_gpu, META, GPU, GObject)
struct _MetaGpuClass
{
GObjectClass parent_class;
gboolean (* read_current) (MetaGpu *gpu,
GError **error);
+ void (* poll_hardware) (MetaGpu *gpu);
};
int meta_gpu_get_kms_fd (MetaGpu *gpu);
const char * meta_gpu_get_kms_file_path (MetaGpu *gpu);
+void meta_gpu_poll_hardware (MetaGpu *gpu);
gboolean meta_gpu_read_current (MetaGpu *gpu,
GError **error);
gboolean meta_gpu_has_hotplug_mode_update (MetaGpu *gpu);
MetaMonitorManager * meta_gpu_get_monitor_manager (MetaGpu *gpu);
GList * meta_gpu_get_outputs (MetaGpu *gpu);
GList * meta_gpu_get_crtcs (MetaGpu *gpu);
GList * meta_gpu_get_modes (MetaGpu *gpu);
void meta_gpu_take_outputs (MetaGpu *gpu,
GList *outputs);
void meta_gpu_take_crtcs (MetaGpu *gpu,
GList *crtcs);
void meta_gpu_take_modes (MetaGpu *gpu,
GList *modes);
#endif /* META_GPU_H */
diff --git a/src/backends/x11/meta-gpu-xrandr.c b/src/backends/x11/meta-gpu-xrandr.c
index 14b46d530..add80c0d2 100644
--- a/src/backends/x11/meta-gpu-xrandr.c
+++ b/src/backends/x11/meta-gpu-xrandr.c
@@ -17,97 +17,107 @@
* 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 "backends/x11/meta-gpu-xrandr.h"
#include <string.h>
#include <X11/extensions/dpms.h>
#include <X11/Xlibint.h>
#include "backends/meta-output.h"
#include "backends/x11/meta-crtc-xrandr.h"
#include "backends/x11/meta-monitor-manager-xrandr.h"
#include "backends/x11/meta-output-xrandr.h"
struct _MetaGpuXrandr
{
MetaGpu parent;
XRRScreenResources *resources;
int max_screen_width;
int max_screen_height;
+
+ gboolean need_hardware_poll;
};
G_DEFINE_TYPE (MetaGpuXrandr, meta_gpu_xrandr, META_TYPE_GPU)
XRRScreenResources *
meta_gpu_xrandr_get_resources (MetaGpuXrandr *gpu_xrandr)
{
return gpu_xrandr->resources;
}
void
meta_gpu_xrandr_get_max_screen_size (MetaGpuXrandr *gpu_xrandr,
int *max_width,
int *max_height)
{
*max_width = gpu_xrandr->max_screen_width;
*max_height = gpu_xrandr->max_screen_height;
}
static int
compare_outputs (const void *one,
const void *two)
{
const MetaOutput *o_one = one, *o_two = two;
return strcmp (o_one->name, o_two->name);
}
static char *
get_xmode_name (XRRModeInfo *xmode)
{
int width = xmode->width;
int height = xmode->height;
return g_strdup_printf ("%dx%d", width, height);
}
+static void
+meta_monitor_manager_xrandr_update (MetaMonitorManagerXrandr *manager_xrandr)
+meta_gpu_xrandr_poll_hardware (MetaGpu *gpu)
+{
+ MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
+ gboolean is_hotplug;
+ gboolean is_our_configuration;
+ unsigned int timestamp;
+
+ meta_monitor_manager_read_current_state (manager);
+ MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (gpu);
+
+ timestamp = manager_xrandr->resources->timestamp;
+ if (is_xvnc (manager))
+ timestamp += 100;
+ gpu_xrandr->need_hardware_poll = TRUE;
+}
+
+ is_hotplug = (timestamp < manager_xrandr->resources->configTimestamp);
+ is_our_configuration = (manager_xrandr->resources->timestamp ==
+ manager_xrandr->last_xrandr_set_timestamp);
+ if (is_hotplug)
static gboolean
meta_gpu_xrandr_read_current (MetaGpu *gpu,
GError **error)
{
MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (gpu);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
MetaMonitorManagerXrandr *monitor_manager_xrandr =
META_MONITOR_MANAGER_XRANDR (monitor_manager);
Display *xdisplay =
meta_monitor_manager_xrandr_get_xdisplay (monitor_manager_xrandr);
XRRScreenResources *resources;
RROutput primary_output;
unsigned int i, j;
GList *l;
int min_width, min_height;
Screen *screen;
BOOL dpms_capable, dpms_enabled;
CARD16 dpms_state;
GList *outputs = NULL;
GList *modes = NULL;
GList *crtcs = NULL;
if (gpu_xrandr->resources)
XRRFreeScreenResources (gpu_xrandr->resources);
gpu_xrandr->resources = NULL;
dpms_capable = DPMSCapable (xdisplay);
if (dpms_capable &&
DPMSInfo (xdisplay, &dpms_state, &dpms_enabled) &&
@@ -121,62 +131,72 @@ meta_gpu_xrandr_read_current (MetaGpu *gpu,
case DPMSModeStandby:
monitor_manager->power_save_mode = META_POWER_SAVE_STANDBY;
break;
case DPMSModeSuspend:
monitor_manager->power_save_mode = META_POWER_SAVE_SUSPEND;
break;
case DPMSModeOff:
monitor_manager->power_save_mode = META_POWER_SAVE_OFF;
break;
default:
monitor_manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
break;
}
}
else
{
monitor_manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
}
XRRGetScreenSizeRange (xdisplay, DefaultRootWindow (xdisplay),
&min_width,
&min_height,
&gpu_xrandr->max_screen_width,
&gpu_xrandr->max_screen_height);
screen = ScreenOfDisplay (xdisplay, DefaultScreen (xdisplay));
/* This is updated because we called XRRUpdateConfiguration. */
monitor_manager->screen_width = WidthOfScreen (screen);
monitor_manager->screen_height = HeightOfScreen (screen);
- resources = XRRGetScreenResourcesCurrent (xdisplay,
- DefaultRootWindow (xdisplay));
+ if (gpu_xrandr->need_hardware_poll)
+ {
+ meta_monitor_manager_on_hotplug (manager);
+ resources = XRRGetScreenResources (xdisplay,
+ DefaultRootWindow (xdisplay));
+ gpu_xrandr->need_hardware_poll = FALSE;
+ }
+ else
+ {
+ MetaMonitorsConfig *config;
+ resources = XRRGetScreenResourcesCurrent (xdisplay,
+ DefaultRootWindow (xdisplay));
+ }
+
+ if (is_our_configuration)
+ {
+ MetaMonitorConfigManager *config_manager =
+ meta_monitor_manager_get_config_manager (manager);
if (!resources)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to retrieve Xrandr screen resources");
return FALSE;
}
gpu_xrandr->resources = resources;
outputs = NULL;
modes = NULL;
crtcs = NULL;
for (i = 0; i < (unsigned)resources->nmode; i++)
{
XRRModeInfo *xmode = &resources->modes[i];
MetaCrtcMode *mode;
mode = g_object_new (META_TYPE_CRTC_MODE, NULL);
mode->mode_id = xmode->id;
mode->width = xmode->width;
mode->height = xmode->height;
mode->refresh_rate = (xmode->dotClock /
((float)xmode->hTotal * xmode->vTotal));
mode->flags = xmode->modeFlags;
mode->name = get_xmode_name (xmode);
modes = g_list_append (modes, mode);
}
@@ -255,42 +275,44 @@ meta_gpu_xrandr_read_current (MetaGpu *gpu,
}
}
}
}
return TRUE;
}
MetaGpuXrandr *
meta_gpu_xrandr_new (MetaMonitorManagerXrandr *monitor_manager_xrandr)
{
return g_object_new (META_TYPE_GPU_XRANDR,
"monitor-manager", monitor_manager_xrandr,
NULL);
}
static void
meta_gpu_xrandr_finalize (GObject *object)
{
MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (object);
g_clear_pointer (&gpu_xrandr->resources,
XRRFreeScreenResources);
G_OBJECT_CLASS (meta_gpu_xrandr_parent_class)->finalize (object);
}
static void
meta_gpu_xrandr_init (MetaGpuXrandr *gpu_xrandr)
{
+ gpu_xrandr->need_hardware_poll = TRUE;
}
static void
meta_gpu_xrandr_class_init (MetaGpuXrandrClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
object_class->finalize = meta_gpu_xrandr_finalize;
gpu_class->read_current = meta_gpu_xrandr_read_current;
+ gpu_class->poll_hardware = meta_gpu_xrandr_poll_hardware;
}
diff --git a/src/backends/x11/meta-monitor-manager-xrandr.c b/src/backends/x11/meta-monitor-manager-xrandr.c
index 90a3952db..2d9a32339 100644
--- a/src/backends/x11/meta-monitor-manager-xrandr.c
+++ b/src/backends/x11/meta-monitor-manager-xrandr.c
@@ -33,95 +33,101 @@
#include <clutter/clutter.h>
#include <X11/Xlibint.h>
#include <X11/extensions/dpms.h>
#include <X11/Xlib-xcb.h>
#include <xcb/randr.h>
#include "meta-backend-x11.h"
#include <meta/main.h>
#include <meta/errors.h>
#include "backends/meta-crtc.h"
#include "backends/meta-monitor-config-manager.h"
#include "backends/meta-logical-monitor.h"
#include "backends/meta-output.h"
#include "backends/x11/meta-crtc-xrandr.h"
#include "backends/x11/meta-gpu-xrandr.h"
#include "backends/x11/meta-output-xrandr.h"
/* Look for DPI_FALLBACK in:
* http://git.gnome.org/browse/gnome-settings-daemon/tree/plugins/xsettings/gsd-xsettings-manager.c
* for the reasoning */
#define DPI_FALLBACK 96.0
struct _MetaMonitorManagerXrandr
{
MetaMonitorManager parent_instance;
Display *xdisplay;
int rr_event_base;
int rr_error_base;
+
+ config = meta_monitor_config_manager_get_current (config_manager);
+ }
+ else
+ {
+ config = NULL;
+ }
+ guint logind_watch_id;
+ guint logind_signal_sub_id;
+
+ meta_monitor_manager_rebuild_derived (manager, config);
+ }
+}
gboolean has_randr15;
/*
* The X server deals with multiple GPUs for us, soe just see what the X
* server gives us as one single GPU, even though it may actually be backed
* by multiple.
*/
MetaGpu *gpu;
xcb_timestamp_t last_xrandr_set_timestamp;
#ifdef HAVE_XRANDR15
GHashTable *tiled_monitor_atoms;
#endif /* HAVE_XRANDR15 */
float *supported_scales;
int n_supported_scales;
};
struct _MetaMonitorManagerXrandrClass
{
MetaMonitorManagerClass parent_class;
};
G_DEFINE_TYPE (MetaMonitorManagerXrandr, meta_monitor_manager_xrandr, META_TYPE_MONITOR_MANAGER);
#ifdef HAVE_XRANDR15
typedef struct _MetaMonitorXrandrData
{
Atom xrandr_name;
} MetaMonitorXrandrData;
GQuark quark_meta_monitor_xrandr_data;
#endif /* HAVE_RANDR15 */
+static void meta_monitor_manager_xrandr_update (MetaMonitorManagerXrandr *manager_xrandr);
+
Display *
meta_monitor_manager_xrandr_get_xdisplay (MetaMonitorManagerXrandr *manager_xrandr)
{
return manager_xrandr->xdisplay;
}
gboolean
meta_monitor_manager_xrandr_has_randr15 (MetaMonitorManagerXrandr *manager_xrandr)
{
return manager_xrandr->has_randr15;
}
static GBytes *
meta_monitor_manager_xrandr_read_edid (MetaMonitorManager *manager,
MetaOutput *output)
{
return meta_output_xrandr_read_edid (output);
}
static void
meta_monitor_manager_xrandr_set_power_save_mode (MetaMonitorManager *manager,
MetaPowerSave mode)
{
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
CARD16 state;
switch (mode) {
case META_POWER_SAVE_ON:
state = DPMSModeOn;
break;
@@ -934,198 +940,272 @@ meta_monitor_manager_xrandr_calculate_supported_scales (MetaMonitorManager
manager_xrandr->n_supported_scales * sizeof (float));
}
static MetaMonitorManagerCapability
meta_monitor_manager_xrandr_get_capabilities (MetaMonitorManager *manager)
{
return (META_MONITOR_MANAGER_CAPABILITY_MIRRORING |
META_MONITOR_MANAGER_CAPABILITY_GLOBAL_SCALE_REQUIRED);
}
static gboolean
meta_monitor_manager_xrandr_get_max_screen_size (MetaMonitorManager *manager,
int *max_width,
int *max_height)
{
MetaMonitorManagerXrandr *manager_xrandr =
META_MONITOR_MANAGER_XRANDR (manager);
meta_gpu_xrandr_get_max_screen_size (META_GPU_XRANDR (manager_xrandr->gpu),
max_width, max_height);
return TRUE;
}
static MetaLogicalMonitorLayoutMode
meta_monitor_manager_xrandr_get_default_layout_mode (MetaMonitorManager *manager)
{
return META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
}
+static void
+logind_signal_handler (GDBusConnection *connection,
+ const gchar *sender_name,
@ -120,7 +539,7 @@ index 8d1bdfb69..d451fcccc 100644 @@ -120,7 +539,7 @@ index 8d1bdfb69..d451fcccc 100644
+ g_variant_get (parameters, "(b)", &suspending);
+ if (!suspending)
+ {
+ manager_xrandr->need_hardware_poll = TRUE;
+ meta_gpu_poll_hardware (manager_xrandr->gpu);
+ meta_monitor_manager_xrandr_update (manager_xrandr);
+ }
+}
@ -159,25 +578,60 @@ index 8d1bdfb69..d451fcccc 100644 @@ -159,25 +578,60 @@ index 8d1bdfb69..d451fcccc 100644
+}
+
static void
meta_monitor_manager_xrandr_init (MetaMonitorManagerXrandr *manager_xrandr)
meta_monitor_manager_xrandr_constructed (GObject *object)
{
@@ -1948,6 +2069,15 @@ meta_monitor_manager_xrandr_init (MetaMonitorManagerXrandr *manager_xrandr)
MetaMonitorManagerXrandr *manager_xrandr =
META_MONITOR_MANAGER_XRANDR (object);
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
MetaBackendX11 *backend =
META_BACKEND_X11 (meta_monitor_manager_get_backend (manager));
manager_xrandr->xdisplay = meta_backend_x11_get_xdisplay (backend);
manager_xrandr->gpu = META_GPU (meta_gpu_xrandr_new (manager_xrandr));
meta_monitor_manager_add_gpu (manager, manager_xrandr->gpu);
if (!XRRQueryExtension (manager_xrandr->xdisplay,
&manager_xrandr->rr_event_base,
&manager_xrandr->rr_error_base))
{
return;
}
else
{
int major_version, minor_version;
/* We only use ScreenChangeNotify, but GDK uses the others,
and we don't want to step on its toes */
XRRSelectInput (manager_xrandr->xdisplay,
DefaultRootWindow (manager_xrandr->xdisplay),
RRScreenChangeNotifyMask
| RRCrtcChangeNotifyMask
| RROutputPropertyNotifyMask);
manager_xrandr->has_randr15 = FALSE;
XRRQueryVersion (manager_xrandr->xdisplay, &major_version,
&minor_version);
#ifdef HAVE_XRANDR15
if (major_version > 1 ||
(major_version == 1 &&
minor_version >= 5))
{
manager_xrandr->has_randr15 = TRUE;
manager_xrandr->tiled_monitor_atoms = g_hash_table_new (NULL, NULL);
}
meta_monitor_manager_xrandr_init_monitors (manager_xrandr);
#endif
}
+
+ manager_xrandr->logind_watch_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
+ "org.freedesktop.login1",
+ G_BUS_NAME_WATCHER_FLAGS_NONE,
+ logind_appeared,
+ logind_vanished,
+ manager_xrandr,
+ NULL);
+ manager_xrandr->need_hardware_poll = TRUE;
G_OBJECT_CLASS (meta_monitor_manager_xrandr_parent_class)->constructed (object);
}
static void
@@ -1962,6 +2092,10 @@ meta_monitor_manager_xrandr_finalize (GObject *object)
meta_monitor_manager_xrandr_finalize (GObject *object)
{
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (object);
g_clear_object (&manager_xrandr->gpu);
g_hash_table_destroy (manager_xrandr->tiled_monitor_atoms);
g_free (manager_xrandr->supported_scales);
@ -188,72 +642,135 @@ index 8d1bdfb69..d451fcccc 100644 @@ -188,72 +642,135 @@ index 8d1bdfb69..d451fcccc 100644
G_OBJECT_CLASS (meta_monitor_manager_xrandr_parent_class)->finalize (object);
}
@@ -1996,64 +2130,16 @@ meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
static void
meta_monitor_manager_xrandr_init (MetaMonitorManagerXrandr *manager_xrandr)
{
+ manager_xrandr->logind_watch_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
+ "org.freedesktop.login1",
+ G_BUS_NAME_WATCHER_FLAGS_NONE,
+ logind_appeared,
+ logind_vanished,
+ manager_xrandr,
+ NULL);
}
static void
meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
{
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = meta_monitor_manager_xrandr_finalize;
object_class->constructed = meta_monitor_manager_xrandr_constructed;
manager_class->read_edid = meta_monitor_manager_xrandr_read_edid;
manager_class->ensure_initial_config = meta_monitor_manager_xrandr_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_xrandr_apply_monitors_config;
manager_class->set_power_save_mode = meta_monitor_manager_xrandr_set_power_save_mode;
manager_class->change_backlight = meta_monitor_manager_xrandr_change_backlight;
manager_class->get_crtc_gamma = meta_monitor_manager_xrandr_get_crtc_gamma;
manager_class->set_crtc_gamma = meta_monitor_manager_xrandr_set_crtc_gamma;
#ifdef HAVE_XRANDR15
manager_class->tiled_monitor_added = meta_monitor_manager_xrandr_tiled_monitor_added;
manager_class->tiled_monitor_removed = meta_monitor_manager_xrandr_tiled_monitor_removed;
#endif
manager_class->is_transform_handled = meta_monitor_manager_xrandr_is_transform_handled;
manager_class->calculate_monitor_mode_scale = meta_monitor_manager_xrandr_calculate_monitor_mode_scale;
manager_class->calculate_supported_scales = meta_monitor_manager_xrandr_calculate_supported_scales;
manager_class->get_capabilities = meta_monitor_manager_xrandr_get_capabilities;
manager_class->get_max_screen_size = meta_monitor_manager_xrandr_get_max_screen_size;
manager_class->get_default_layout_mode = meta_monitor_manager_xrandr_get_default_layout_mode;
quark_meta_monitor_xrandr_data =
g_quark_from_static_string ("-meta-monitor-xrandr-data");
}
-static gboolean
-is_xvnc (MetaMonitorManager *manager)
-{
- unsigned int i;
-
- for (i = 0; i < manager->n_outputs; ++i)
- if (g_str_has_prefix (manager->outputs[i].name, "VNC-"))
- return TRUE;
-
- return FALSE;
-}
-
gboolean
meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xrandr,
XEvent *event)
static gboolean
is_xvnc (MetaMonitorManager *manager)
{
- MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
- gboolean is_hotplug;
- gboolean is_our_configuration;
- unsigned int timestamp;
-
if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
return FALSE;
MetaMonitorManagerXrandr *manager_xrandr =
META_MONITOR_MANAGER_XRANDR (manager);
GList *l;
XRRUpdateConfiguration (event);
for (l = meta_gpu_get_outputs (manager_xrandr->gpu); l; l = l->next)
{
MetaOutput *output = l->data;
- meta_monitor_manager_read_current_state (manager);
-
-
- timestamp = manager_xrandr->resources->timestamp;
- if (is_xvnc (manager))
- timestamp += 100;
-
- is_hotplug = (timestamp < manager_xrandr->resources->configTimestamp);
- is_our_configuration = (manager_xrandr->resources->timestamp ==
- manager_xrandr->last_xrandr_set_timestamp);
- if (is_hotplug)
- {
- meta_monitor_manager_on_hotplug (manager);
- }
- else
- {
- MetaMonitorsConfig *config;
-
- if (is_our_configuration)
- {
- MetaMonitorConfigManager *config_manager =
- meta_monitor_manager_get_config_manager (manager);
if (g_str_has_prefix (output->name, "VNC-"))
return TRUE;
}
return FALSE;
}
-gboolean
-meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xrandr,
- XEvent *event)
+static void
+meta_monitor_manager_xrandr_update (MetaMonitorManagerXrandr *manager_xrandr)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
MetaGpuXrandr *gpu_xrandr;
XRRScreenResources *resources;
gboolean is_hotplug;
gboolean is_our_configuration;
unsigned int timestamp;
- if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
- return FALSE;
-
- config = meta_monitor_config_manager_get_current (config_manager);
- }
- else
- {
- config = NULL;
- }
- XRRUpdateConfiguration (event);
-
- meta_monitor_manager_xrandr_rebuild_derived (manager, config);
- }
meta_monitor_manager_read_current_state (manager);
gpu_xrandr = META_GPU_XRANDR (manager_xrandr->gpu);
resources = meta_gpu_xrandr_get_resources (gpu_xrandr);
timestamp = resources->timestamp;
if (is_xvnc (manager))
timestamp += 100;
is_hotplug = timestamp < resources->configTimestamp;
is_our_configuration = (resources->timestamp ==
manager_xrandr->last_xrandr_set_timestamp);
if (is_hotplug)
{
meta_monitor_manager_on_hotplug (manager);
}
else
{
MetaMonitorsConfig *config;
if (is_our_configuration)
{
MetaMonitorConfigManager *config_manager =
meta_monitor_manager_get_config_manager (manager);
config = meta_monitor_config_manager_get_current (config_manager);
}
else
{
config = NULL;
}
meta_monitor_manager_xrandr_rebuild_derived (manager, config);
}
+}
+
+gboolean
+meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xrandr,
+ XEvent *event)
+{
+
+ if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
+ return FALSE;
+
+ XRRUpdateConfiguration (event);
+
+ meta_monitor_manager_xrandr_update (manager_xrandr);
return TRUE;
}
--
2.14.2
2.17.1


48
SOURCES/0001-monitor-manager-xrandr-Work-around-spurious-hotplugs.patch

@ -1,8 +1,7 @@ @@ -1,8 +1,7 @@
From 73cae2c78af65cdfd6fa0c8257b4d3ae593f9f74 Mon Sep 17 00:00:00 2001
From ad61347e9d92380fbbb4effd8a19349777d76715 Mon Sep 17 00:00:00 2001
From: Rui Matos <tiagomatos@gmail.com>
Date: Tue, 6 Oct 2015 21:16:18 +0200
Subject: [PATCH 2/8] monitor-manager-xrandr: Work around spurious hotplugs on
Xvnc
Subject: [PATCH] monitor-manager-xrandr: Work around spurious hotplugs on Xvnc

Xvnc turns its outputs off/on on every mode set which makes us believe
there was an hotplug when there actually wasn't. Work around this by
@ -10,25 +9,31 @@ requiring new randr configuration timestamps to be ahead of the last @@ -10,25 +9,31 @@ requiring new randr configuration timestamps to be ahead of the last
set timestamp by at least 100 ms for us to consider them an actual
hotplug.
---
src/backends/x11/meta-monitor-manager-xrandr.c | 20 ++++++++++++++++++--
1 file changed, 18 insertions(+), 2 deletions(-)
.../x11/meta-monitor-manager-xrandr.c | 25 ++++++++++++++++++-
1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/backends/x11/meta-monitor-manager-xrandr.c b/src/backends/x11/meta-monitor-manager-xrandr.c
index c369d4960..8d1bdfb69 100644
index dbe3e4e3b..90a3952db 100644
--- a/src/backends/x11/meta-monitor-manager-xrandr.c
+++ b/src/backends/x11/meta-monitor-manager-xrandr.c
@@ -1909,6 +1909,18 @@ meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
@@ -1058,6 +1058,24 @@ meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
g_quark_from_static_string ("-meta-monitor-xrandr-data");
}
+static gboolean
+is_xvnc (MetaMonitorManager *manager)
+{
+ unsigned int i;
+ MetaMonitorManagerXrandr *manager_xrandr =
+ META_MONITOR_MANAGER_XRANDR (manager);
+ GList *l;
+
+ for (i = 0; i < manager->n_outputs; ++i)
+ if (g_str_has_prefix (manager->outputs[i].name, "VNC-"))
+ return TRUE;
+ for (l = meta_gpu_get_outputs (manager_xrandr->gpu); l; l = l->next)
+ {
+ MetaOutput *output = l->data;
+
+ if (g_str_has_prefix (output->name, "VNC-"))
+ return TRUE;
+ }
+
+ return FALSE;
+}
@ -36,28 +41,27 @@ index c369d4960..8d1bdfb69 100644 @@ -36,28 +41,27 @@ index c369d4960..8d1bdfb69 100644
gboolean
meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xrandr,
XEvent *event)
@@ -1916,6 +1928,7 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
@@ -1067,6 +1085,7 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
XRRScreenResources *resources;
gboolean is_hotplug;
gboolean is_our_configuration;
+ unsigned int timestamp;
if ((event->type - manager_xrandr->rr_event_base) != RRScreenChangeNotify)
return FALSE;
@@ -1925,8 +1938,11 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
meta_monitor_manager_read_current_state (manager);
@@ -1078,7 +1097,11 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
gpu_xrandr = META_GPU_XRANDR (manager_xrandr->gpu);
resources = meta_gpu_xrandr_get_resources (gpu_xrandr);
- is_hotplug = (manager_xrandr->resources->timestamp <
- manager_xrandr->resources->configTimestamp);
+ timestamp = manager_xrandr->resources->timestamp;
- is_hotplug = resources->timestamp < resources->configTimestamp;
+ timestamp = resources->timestamp;
+ if (is_xvnc (manager))
+ timestamp += 100;
+
+ is_hotplug = (timestamp < manager_xrandr->resources->configTimestamp);
is_our_configuration = (manager_xrandr->resources->timestamp ==
+ is_hotplug = timestamp < resources->configTimestamp;
is_our_configuration = (resources->timestamp ==
manager_xrandr->last_xrandr_set_timestamp);
if (is_hotplug)
--
2.14.2
2.17.0


76
SOURCES/0008-Add-support-for-quad-buffer-stereo.patch

@ -1,7 +1,7 @@ @@ -1,7 +1,7 @@
From 7940ea62307044c056c16f1534e3e8e94cc7a352 Mon Sep 17 00:00:00 2001
From 77b95bdac1b3cca4d06480e1d7fe1b6c86a32d2f Mon Sep 17 00:00:00 2001
From: "Owen W. Taylor" <otaylor@fishsoup.net>
Date: Thu, 8 May 2014 18:44:15 -0400
Subject: [PATCH 7/8] Add support for quad-buffer stereo
Subject: [PATCH] Add support for quad-buffer stereo

Track the stereo status of windows using the new EXT_stereo_tree
GLX extension.
@ -37,10 +37,10 @@ texture_from_pixmap. @@ -37,10 +37,10 @@ texture_from_pixmap.
create mode 100644 src/core/stereo.h

diff --git a/src/Makefile.am b/src/Makefile.am
index 6aef50de8..8c680602c 100644
index 5bbac70..8b21d2f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -281,6 +281,8 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
@@ -308,6 +308,8 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
core/stack.h \
core/stack-tracker.c \
core/stack-tracker.h \
@ -50,7 +50,7 @@ index 6aef50de8..8c680602c 100644 @@ -50,7 +50,7 @@ index 6aef50de8..8c680602c 100644
meta/util.h \
core/util-private.h \
diff --git a/src/compositor/compositor-private.h b/src/compositor/compositor-private.h
index ba58bf175..1c257b5ee 100644
index 40c0344..25cab92 100644
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -21,6 +21,10 @@ struct _MetaCompositor
@ -77,11 +77,11 @@ index ba58bf175..1c257b5ee 100644 @@ -77,11 +77,11 @@ index ba58bf175..1c257b5ee 100644
MetaWindow *window);
diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
index 17e8a55dd..a1bf1a8f8 100644
index 8c924d2..e12fb7b 100644
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -70,6 +70,8 @@
#include "meta-window-group.h"
#include "meta-window-group-private.h"
#include "window-private.h" /* to check window->hidden */
#include "display-private.h" /* for meta_display_lookup_x_window() and meta_display_cancel_touch() */
+#include "stack-tracker.h"
@ -89,7 +89,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -89,7 +89,7 @@ index 17e8a55dd..a1bf1a8f8 100644
#include "util-private.h"
#include "backends/meta-dnd-private.h"
#include "frame.h"
@@ -482,6 +484,97 @@ redirect_windows (MetaScreen *screen)
@@ -487,6 +489,97 @@ redirect_windows (MetaScreen *screen)
}
}
@ -187,7 +187,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -187,7 +187,7 @@ index 17e8a55dd..a1bf1a8f8 100644
void
meta_compositor_manage (MetaCompositor *compositor)
{
@@ -490,6 +583,8 @@ meta_compositor_manage (MetaCompositor *compositor)
@@ -495,6 +588,8 @@ meta_compositor_manage (MetaCompositor *compositor)
MetaScreen *screen = display->screen;
MetaBackend *backend = meta_get_backend ();
@ -196,7 +196,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -196,7 +196,7 @@ index 17e8a55dd..a1bf1a8f8 100644
meta_screen_set_cm_selection (display->screen);
compositor->stage = meta_backend_get_stage (backend);
@@ -757,6 +852,23 @@ meta_compositor_process_event (MetaCompositor *compositor,
@@ -759,6 +854,23 @@ meta_compositor_process_event (MetaCompositor *compositor,
if (window)
process_damage (compositor, (XDamageNotifyEvent *) event, window);
}
@ -220,7 +220,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -220,7 +220,7 @@ index 17e8a55dd..a1bf1a8f8 100644
if (compositor->have_x11_sync_object)
meta_sync_ring_handle_event (event);
@@ -957,6 +1069,7 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
@@ -969,6 +1081,7 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
GList *stack)
{
GList *old_stack;
@ -228,7 +228,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -228,7 +228,7 @@ index 17e8a55dd..a1bf1a8f8 100644
/* This is painful because hidden windows that we are in the process
* of animating out of existence. They'll be at the bottom of the
@@ -1032,6 +1145,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
@@ -1044,6 +1157,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
* near the front of the other.)
*/
compositor->windows = g_list_prepend (compositor->windows, actor);
@ -237,16 +237,16 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -237,16 +237,16 @@ index 17e8a55dd..a1bf1a8f8 100644
stack = g_list_remove (stack, window);
old_stack = g_list_remove (old_stack, actor);
@@ -1039,6 +1154,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
@@ -1051,6 +1166,8 @@ meta_compositor_sync_stack (MetaCompositor *compositor,
sync_actor_stacking (compositor);
+ meta_stereo_set_have_stereo_windows (stereo_window_count > 0);
+
compositor->top_window_actor = get_top_visible_window_actor (compositor);
}
@@ -1237,6 +1354,17 @@ meta_compositor_new (MetaDisplay *display)
if (compositor->top_window_actor)
g_signal_handlers_disconnect_by_func (compositor->top_window_actor,
on_top_window_actor_destroyed,
@@ -1259,6 +1376,17 @@ meta_compositor_new (MetaDisplay *display)
meta_post_paint_func,
compositor,
NULL);
@ -265,7 +265,7 @@ index 17e8a55dd..a1bf1a8f8 100644 @@ -265,7 +265,7 @@ index 17e8a55dd..a1bf1a8f8 100644
}
diff --git a/src/compositor/meta-shaped-texture-private.h b/src/compositor/meta-shaped-texture-private.h
index 5b3f283c2..189a95312 100644
index 5b3f283..189a953 100644
--- a/src/compositor/meta-shaped-texture-private.h
+++ b/src/compositor/meta-shaped-texture-private.h
@@ -30,8 +30,9 @@
@ -281,7 +281,7 @@ index 5b3f283c2..189a95312 100644 @@ -281,7 +281,7 @@ index 5b3f283c2..189a95312 100644
gboolean is_y_inverted);
void meta_shaped_texture_set_snippet (MetaShapedTexture *stex,
diff --git a/src/compositor/meta-shaped-texture.c b/src/compositor/meta-shaped-texture.c
index 98346c6ae..b89de03a3 100644
index 98346c6..b89de03 100644
--- a/src/compositor/meta-shaped-texture.c
+++ b/src/compositor/meta-shaped-texture.c
@@ -74,8 +74,10 @@ static guint signals[LAST_SIGNAL];
@ -550,10 +550,10 @@ index 98346c6ae..b89de03a3 100644 @@ -550,10 +550,10 @@ index 98346c6ae..b89de03a3 100644
/**
diff --git a/src/compositor/meta-surface-actor-wayland.c b/src/compositor/meta-surface-actor-wayland.c
index 551322573..6ca68eb64 100644
index 7505b7d..9475c20 100644
--- a/src/compositor/meta-surface-actor-wayland.c
+++ b/src/compositor/meta-surface-actor-wayland.c
@@ -403,7 +403,7 @@ meta_surface_actor_wayland_dispose (GObject *object)
@@ -187,7 +187,7 @@ meta_surface_actor_wayland_dispose (GObject *object)
MetaShapedTexture *stex =
meta_surface_actor_get_texture (META_SURFACE_ACTOR (self));
@ -562,7 +562,7 @@ index 551322573..6ca68eb64 100644 @@ -562,7 +562,7 @@ index 551322573..6ca68eb64 100644
if (priv->surface)
{
g_object_remove_weak_pointer (G_OBJECT (priv->surface),
@@ -462,6 +462,14 @@ meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
@@ -246,6 +246,14 @@ meta_surface_actor_wayland_new (MetaWaylandSurface *surface)
return META_SURFACE_ACTOR (self);
}
@ -578,7 +578,7 @@ index 551322573..6ca68eb64 100644 @@ -578,7 +578,7 @@ index 551322573..6ca68eb64 100644
meta_surface_actor_wayland_get_surface (MetaSurfaceActorWayland *self)
{
diff --git a/src/compositor/meta-surface-actor-x11.c b/src/compositor/meta-surface-actor-x11.c
index d32aeb68a..52db3808e 100644
index d32aeb6..52db380 100644
--- a/src/compositor/meta-surface-actor-x11.c
+++ b/src/compositor/meta-surface-actor-x11.c
@@ -31,6 +31,7 @@
@ -716,7 +716,7 @@ index d32aeb68a..52db3808e 100644 @@ -716,7 +716,7 @@ index d32aeb68a..52db3808e 100644
+ return priv->stereo;
+}
diff --git a/src/compositor/meta-surface-actor-x11.h b/src/compositor/meta-surface-actor-x11.h
index 0e692ee0f..4b2ecccb1 100644
index 0e692ee..4b2eccc 100644
--- a/src/compositor/meta-surface-actor-x11.h
+++ b/src/compositor/meta-surface-actor-x11.h
@@ -64,6 +64,11 @@ MetaSurfaceActor * meta_surface_actor_x11_new (MetaWindow *window);
@ -732,12 +732,12 @@ index 0e692ee0f..4b2ecccb1 100644 @@ -732,12 +732,12 @@ index 0e692ee0f..4b2ecccb1 100644
#endif /* __META_SURFACE_ACTOR_X11_H__ */
diff --git a/src/compositor/meta-window-actor-private.h b/src/compositor/meta-window-actor-private.h
index 72dcd1451..035d756b2 100644
index ce5e7ea..5b011ce 100644
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -59,4 +59,9 @@ void meta_window_actor_effect_completed (MetaWindowActor *actor,
MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
@@ -60,4 +60,9 @@ MetaSurfaceActor *meta_window_actor_get_surface (MetaWindowActor *self);
void meta_window_actor_update_surface (MetaWindowActor *self);
MetaWindowActor *meta_window_actor_from_window (MetaWindow *window);
+void meta_window_actor_stereo_notify (MetaWindowActor *actor,
+ gboolean stereo_tree);
@ -746,12 +746,12 @@ index 72dcd1451..035d756b2 100644 @@ -746,12 +746,12 @@ index 72dcd1451..035d756b2 100644
+
#endif /* META_WINDOW_ACTOR_PRIVATE_H */
diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c
index 1184cd422..773e6d09d 100644
index 120b043..b2c7725 100644
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -2150,3 +2150,25 @@ meta_window_actor_sync_updates_frozen (MetaWindowActor *self)
meta_window_actor_set_updates_frozen (self, meta_window_updates_are_frozen (window));
@@ -2189,3 +2189,25 @@ meta_window_actor_from_window (MetaWindow *window)
{
return META_WINDOW_ACTOR (meta_window_get_compositor_private (window));
}
+
+void
@ -776,7 +776,7 @@ index 1184cd422..773e6d09d 100644 @@ -776,7 +776,7 @@ index 1184cd422..773e6d09d 100644
+ return FALSE;
+}
diff --git a/src/core/main.c b/src/core/main.c
index dc1f1c4f6..2c1160711 100644
index 04a42c7..faa2081 100644
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -47,6 +47,7 @@
@ -787,7 +787,7 @@ index dc1f1c4f6..2c1160711 100644 @@ -787,7 +787,7 @@ index dc1f1c4f6..2c1160711 100644
#include <meta/errors.h>
#include "ui.h"
#include <meta/prefs.h>
@@ -566,6 +567,9 @@ meta_init (void)
@@ -580,6 +581,9 @@ meta_init (void)
meta_init_backend (backend_gtype);
@ -799,7 +799,7 @@ index dc1f1c4f6..2c1160711 100644 @@ -799,7 +799,7 @@ index dc1f1c4f6..2c1160711 100644
#ifdef HAVE_WAYLAND
diff --git a/src/core/stereo.c b/src/core/stereo.c
new file mode 100644
index 000000000..5a232b67c
index 0000000..5a232b6
--- /dev/null
+++ b/src/core/stereo.c
@@ -0,0 +1,153 @@
@ -958,7 +958,7 @@ index 000000000..5a232b67c @@ -958,7 +958,7 @@ index 000000000..5a232b67c
+}
diff --git a/src/core/stereo.h b/src/core/stereo.h
new file mode 100644
index 000000000..ccd1d702a
index 0000000..ccd1d70
--- /dev/null
+++ b/src/core/stereo.h
@@ -0,0 +1,28 @@
@ -991,10 +991,10 @@ index 000000000..ccd1d702a @@ -991,10 +991,10 @@ index 000000000..ccd1d702a
+
+#endif
diff --git a/src/wayland/meta-wayland-surface.c b/src/wayland/meta-wayland-surface.c
index 6f9df37da..d353ae5d0 100644
index 899f777..f8f7fc5 100644
--- a/src/wayland/meta-wayland-surface.c
+++ b/src/wayland/meta-wayland-surface.c
@@ -789,7 +789,7 @@ apply_pending_state (MetaWaylandSurface *surface,
@@ -667,7 +667,7 @@ meta_wayland_surface_apply_pending_state (MetaWaylandSurface *surface,
snippet = meta_wayland_buffer_create_snippet (pending->buffer);
is_y_inverted = meta_wayland_buffer_is_y_inverted (pending->buffer);
@ -1004,5 +1004,5 @@ index 6f9df37da..d353ae5d0 100644 @@ -1004,5 +1004,5 @@ index 6f9df37da..d353ae5d0 100644
meta_shaped_texture_set_is_y_inverted (stex, is_y_inverted);
g_clear_pointer (&snippet, cogl_object_unref);
--
2.14.2
1.8.3.1


71
SOURCES/fix-crash-when-modal-closes-during-drag.patch

@ -0,0 +1,71 @@ @@ -0,0 +1,71 @@
From 33bf5319baec86e6caef5b94c71db8101fb94343 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Florian=20M=C3=BCllner?= <fmuellner@gnome.org>
Date: Fri, 25 May 2018 20:18:23 +0200
Subject: [PATCH 1/2] window: Don't refuse to move focus to the grab window

We refuse to move focus while a grab operation is in place. While this
generally makes sense, there's no reason why the window that owns the
grab shouldn't be given the regular input focus as well - we pretty
much assume that the grab window is also the focus window anyway.

In fact there's a strong reason for allowing the focus change here:
If the grab window isn't the focus window, it probably has a modal
transient that is focused instead, and a likely reason for the focus
request is that the transient is being unmanaged and we must move
the focus elsewhere.

https://gitlab.gnome.org/GNOME/mutter/issues/15
---
src/core/window.c | 1 +
1 file changed, 1 insertion(+)

diff --git a/src/core/window.c b/src/core/window.c
index 743326c60..5b1eb5b68 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -4620,6 +4620,7 @@ meta_window_focus (MetaWindow *window,
window->desc, window->input, window->take_focus);
if (window->display->grab_window &&
+ window->display->grab_window != window &&
window->display->grab_window->all_keys_grabbed &&
!window->display->grab_window->unmanaging)
{
--
2.17.1


From 149ae05df628480e8226f035044e6020305a8aeb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Florian=20M=C3=BCllner?= <fmuellner@gnome.org>
Date: Fri, 25 May 2018 21:24:17 +0200
Subject: [PATCH 2/2] window: Explicitly exclude unmanaging window from focus
again

Since commit b3b9d9e16 we no longer have to pass the unmanaging window
to make sure we don't try to focus it again, however the parameter also
influences the focus policy by giving ancestors preference over the normal
stack order.

https://gitlab.gnome.org/GNOME/mutter/issues/15
---
src/core/window.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/core/window.c b/src/core/window.c
index 5b1eb5b68..cc0813ac4 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -1469,7 +1469,9 @@ meta_window_unmanage (MetaWindow *window,
meta_topic (META_DEBUG_FOCUS,
"Focusing default window since we're unmanaging %s\n",
window->desc);
- meta_workspace_focus_default_window (window->screen->active_workspace, NULL, timestamp);
+ meta_workspace_focus_default_window (window->screen->active_workspace,
+ window,
+ timestamp);
}
else
{
--
2.17.1

3006
SOURCES/hw-cursor-on-demand-gnome-3-28.patch

File diff suppressed because it is too large Load Diff

79
SPECS/mutter.spec

@ -3,27 +3,28 @@ @@ -3,27 +3,28 @@
%global gsettings_desktop_schemas_version 3.21.4
%global json_glib_version 0.12.0
%global libinput_version 1.4
%global wayland_protocols_version 1.9.0

%ifarch s390 s390x
%global disable_wayland --disable-wayland-egl-server --disable-wayland --disable-native-backend
%endif

Name: mutter
Version: 3.26.2
Release: 13%{?dist}
Version: 3.28.3
Release: 4%{?dist}
Summary: Window and compositing manager based on Clutter

License: GPLv2+
#VCS: git:git://git.gnome.org/mutter
URL: http://www.gnome.org
Source0: http://download.gnome.org/sources/%{name}/3.26/%{name}-%{version}.tar.xz
Source0: http://download.gnome.org/sources/%{name}/3.28/%{name}-%{version}.tar.xz

Patch0: startup-notification.patch

Patch1: deal-more-gracefully-with-oversized-windows.patch

# Work-around for Xvnc resizing (#1265511)
Patch2: 0001-monitor-manager-xrandr-Work-around-spurious-hotplugs.patch

Patch3: 0001-monitor-manager-xrandr-Force-an-update-when-resuming.patch
Patch4: 0001-monitor-manager-Consider-external-layout-before-defa.patch

@ -32,32 +33,31 @@ Patch6: 0001-backends-x11-Support-synaptics-configuration.patch @@ -32,32 +33,31 @@ Patch6: 0001-backends-x11-Support-synaptics-configuration.patch

Patch7: 0001-window-actor-Special-case-shaped-Java-windows.patch

Patch8: 0001-backends-x11-Preserve-XI1-XDevice-throughout-Clutter.patch
Patch9: 0001-clutter-Extend-touchpad-device-property-check-for-Sy.patch
Patch10: 0001-backends-x11-wacom-pressure-curve-is-a-32-bit-proper.patch

Patch11: 0001-renderer-x11-Enable-GPU-memory-purge-error-extension.patch
Patch12: 0001-backends-Monitor-changes-in-active-tools-settings.patch
Patch13: 0001-clutter-x11-Implement-missing-ClutterInputDevice-pad.patch
Patch10: 0001-clutter-x11-Implement-keycode-lookup-from-keysyms-on.patch

# http://bugzilla.gnome.org/show_bug.cgi?id=733277
Patch20: 0008-Add-support-for-quad-buffer-stereo.patch
Patch21: 0001-build-Lower-automake-requirement.patch

# https://bugzilla.redhat.com/show_bug.cgi?id=1618632
# https://bugzilla.redhat.com/show_bug.cgi?id=1497303
Patch31: 0001-monitor-manager-only-reuse-initial-config-if-monitor.patch

# el7 patches
Patch100: 0001-Revert-build-Require-libgudev-232.patch
Patch101: 0001-rhel7-Fix-build-for-el7.patch
Patch102: mutter-3.26.0-hybrid-gpus.patch
Patch103: 0001-wayland-enable-scale-monitor-framebuffer-by-default.patch
Patch104: add-support-for-plain-old-x-device-configuration.patch
Patch105: remember-saved-multi-monitor-configuration.patch
Patch106: 0003-window-wayland-Handle-resizing-when-headless.patch
Patch107: fix-session-save-crash.patch
Patch108: 0001-wayland-Do-not-fail-on-stalled-.X11-unix-entries.patch
Patch109: 0001-main-be-more-aggressive-in-assuming-X11-backend.patch
Patch110: 0001-clutter-Only-reset-scroll-axes-on-slave-devices.patch
Patch111: fix-crash-when-modal-closes-during-drag.patch

Patch500: 0001-clutter-stage-don-t-use-deprecated-api.patch

# Fedora patches:
# Upload HW cursor on demand, avoiding stuttering on hybrid GPU laptops
Patch201: hw-cursor-on-demand-gnome-3-28.patch
# Check hw support for calculated view transform
Patch202: 0001-renderer-native-Check-calculated-transform-when-crea.patch

BuildRequires: chrpath
BuildRequires: pango-devel
@ -88,6 +88,7 @@ BuildRequires: mesa-libGLES-devel @@ -88,6 +88,7 @@ BuildRequires: mesa-libGLES-devel
BuildRequires: mesa-libGL-devel
BuildRequires: mesa-libgbm-devel
BuildRequires: pam-devel
BuildRequires: systemd-devel
BuildRequires: upower-devel
BuildRequires: xkeyboard-config-devel
BuildRequires: zenity
@ -107,7 +108,6 @@ BuildRequires: libgudev1-devel @@ -107,7 +108,6 @@ BuildRequires: libgudev1-devel
%ifnarch s390 s390x
BuildRequires: libwayland-server-devel
BuildRequires: libinput-devel >= %{libinput_version}
BuildRequires: wayland-protocols-devel >= %{wayland_protocols_version}
%endif

Obsoletes: mutter-wayland < 3.13.0
@ -125,7 +125,6 @@ Requires: dbus-x11 @@ -125,7 +125,6 @@ Requires: dbus-x11
Requires: zenity

Requires: json-glib%{?_isa} >= %{json_glib_version}

%ifnarch s390 s390x
Requires: libinput%{?_isa} >= %{libinput_version}
%endif
@ -215,6 +214,48 @@ glib-compile-schemas %{_datadir}/glib-2.0/schemas &> /dev/null || : @@ -215,6 +214,48 @@ glib-compile-schemas %{_datadir}/glib-2.0/schemas &> /dev/null || :
%{_libdir}/pkgconfig/*

%changelog
* Fri Sep 21 2018 Ray Strode <rstrode@redhat.com> - 3.28.3-4
- Fix crasher introduced in the previous build
Related: #1497303 1618632

* Wed Sep 19 2018 Ray Strode <rstrode@redhat.com> - 3.28.3-3
- ensure monitor hotplugged after start up is activated
Resolves: #1497303 1618632

* Tue Sep 04 2018 Florian Müllner <fmuellner@redhat.com> - 3.28.3-2
- Fix non-lowercase letters on virtual key devices
- Resolves: #1521077

* Wed Aug 01 2018 Kalev Lember <klember@redhat.com> - 3.28.3-1
- Update to 3.28.3
- Apply HW cursor on-demand patches
- Apply monitor transform regression patch
- Resolves: #1569736

* Thu Jul 26 2018 Florian Müllner <fmuellner@redhat.com> - 3.28.2-5
- Fix crash when modal closes during drag
Resolves: #1581454

* Wed Jul 18 2018 Ray Strode <rstrode@redhat.com> - 3.28.2-4
- rebuild against correct gnome-desktop
Related: #1593782

* Fri Jun 22 2018 Florian Müllner <fmuellner@redhat.com> - 3.28.2-3
- Fix support for external monitor configurations
- Resolves: #1585230

* Tue Jun 19 2018 Carlos Garnacho <cgarnach@redhat.com> - 3.28.2-2
- Update scroll axes only in slave devices
- Resolves: #1423374

* Mon May 07 2018 Florian Müllner <fmuellner@redhat.com> - 3.28.2-1
- Update to 3.28.2
- Resolves: #1569736

* Tue Apr 17 2018 Carlos Garnacho <cgarnach@redhat.com> - 3.26.2-14
- Add support for Wacom Pro Pen 3D styli
Resolves: #1564063

* Fri Feb 23 2018 Carlos Garnacho <cgarnach@redhat.com> - 3.26.2-13
- Fix pad ring/strip modes
Resolves: #1543633

Loading…
Cancel
Save