Merge lp:~unity-team/unity/x-sru5 into lp:unity/7.4

[Marco Trevisan (Treviño)]

Releasing unity SRU 5 as unity-7.4.5

Backported upstream commits with no changes (a part from revision 4143 which is an half-backport of the upstream 4193, minus the systemd bits)

[Andrea Azzarone (azzar1)]

LGTM now thanks!

review: Approve

[Andrea Azzarone (azzar1)]

review: Needs Fixing

[Andrea Azzarone (azzar1)]

Works fine now!

review: Approve

[Amr Ibrahim (amribrahim1987)]

Ping!
SRU into Xenial.

=== modified file 'AUTHORS'
--- AUTHORS	2016-05-14 23:01:37 +0000
+++ AUTHORS	2017-12-01 18:43:57 +0000
@@ -4,6 +4,7 @@
  [e-mail]
  Alan Pope <[e-mail]>
  Albert Astals <[e-mail]>
+ Alberto Milone <[e-mail]>
  Alejandro Piñeiro <[e-mail]>
  Alexander Fougner <[e-mail]>
  Alexandre Abreu <[e-mail]>
@@ -80,6 +81,7 @@
  [e-mail]
  Jonas Schwabe
  Jussi Pakkanen <[e-mail]>
+ Kai-Heng Feng <[e-mail]>
  Ken VanDine <[e-mail]>
  Kevin DuBois <[e-mail]>
  Koichi Akabe <[e-mail]>
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-08-01 08:37:57 +0000
+++ CMakeLists.txt	2017-12-01 18:43:57 +0000
@@ -11,7 +11,7 @@
 set (PROJECT_NAME "unity")
 set (UNITY_MAJOR 7)
 set (UNITY_MINOR 4)
-set (UNITY_MICRO 0)
+set (UNITY_MICRO 5)
 set (UNITY_VERSION "${UNITY_MAJOR}.${UNITY_MINOR}.${UNITY_MICRO}")
 set (UNITY_API_VERSION "6.0")
 set (UNITY_COMPONENTS_VERSION "6")
@@ -158,14 +158,15 @@
 #
 set (VERSION "${UNITY_VERSION}")
 set (PREFIXPATH "${CMAKE_INSTALL_PREFIX}")
-set (UNITYLIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}")
-set (UNITYDATADIR "${CMAKE_INSTALL_FULL_DATADIR}/${PROJECT_NAME}")
-set (PKGDATADIR "${UNITYDATADIR}/icons")
+set (UNITY_LIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}")
+set (UNITY_DATADIR "${CMAKE_INSTALL_FULL_DATADIR}/${PROJECT_NAME}")
+set (UNITY_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}")
+set (PKGDATADIR "${UNITY_DATADIR}/icons")
 set (SOURCEDATADIR "${CMAKE_CURRENT_SOURCE_DIR}/resources")
 set (BUILDDIR "${CMAKE_BINARY_DIR}")
 set (TESTDATADIR "${CMAKE_CURRENT_SOURCE_DIR}/tests/data")
 set (LOCALE_DIR "${CMAKE_INSTALL_FULL_LOCALEDIR}")
-# specify the domain directly rather than refering to a variable 
+# specify the domain directly rather than refering to a variable
 # like ${PROJECT_NAME} to no confuse dh_translations
 set (GETTEXT_PACKAGE "unity")
 
@@ -182,7 +183,6 @@
 #
 # i18n
 #
-
 find_package (Gettext REQUIRED)
 
 set (COMPIZ_I18N_DIR ${CMAKE_SOURCE_DIR}/po)
@@ -203,7 +203,7 @@
 
 #
 # Enable or disable boot logging
-# 
+#
 option (BOOT_LOGGER "Enable startup performance logging" OFF)
 if (BOOT_LOGGER)
     SET (BOOT_LOGGER_FLAG "-DENABLE_LOGGER")
@@ -248,7 +248,7 @@
     libnotify
     libstartup-notification-1.0
     nux-4.0>=4.0.5
-    sigc++-2.0
+    sigc++-2.0>=2.4.0
     unity-misc>=0.4.0
     xpathselect=1.4
     zeitgeist-2.0
@@ -259,7 +259,7 @@
 if(ENABLE_X_SUPPORT)
   set(UNITY_PLUGIN_DEPS
       ${UNITY_PLUGIN_DEPS}
-      compiz>=0.9.9
+      compiz>=0.9.11
       libgeis
       x11
       xfixes
@@ -304,56 +304,7 @@
 add_subdirectory(gnome)
 
 if (ENABLE_UNIT_TESTS)
-  # Check for google test and build it locally
-  set (
-    GMOCK_ROOT_DIR
-    "/usr/src/gmock"
-    CACHE
-    PATH
-    "Path to Google mock srcs"
-  )
-
-  set (
-    GMOCK_INCLUDE_DIR
-    "/usr/include/gmock/include"
-    CACHE
-    PATH
-    "Path to Google mock include"
-  )
-
-  set(
-    GTEST_ROOT_DIR
-    "${GMOCK_ROOT_DIR}/gtest" # Default value, adjustable by user with e.g., ccmake
-    CACHE
-    PATH
-    "Path to Google test srcs"
-  )
-
-  set(
-    GTEST_INCLUDE_DIR
-    "${GMOCK_ROOT_DIR}/gtest/include"
-    CACHE
-    PATH
-    "Path to Google tests include"
-  )
-
-  if (GTEST_INCLUDE_DIR AND GMOCK_INCLUDE_DIR)
-    include_directories (
-      ${GMOCK_INCLUDE_DIR}
-      ${GTEST_INCLUDE_DIR}
-    )
-    add_subdirectory(
-      ${GMOCK_ROOT_DIR}
-      "${CMAKE_CURRENT_BINARY_DIR}/gmock"
-    )
-  elseif (GTEST_INCLUDE_DIR AND NOT GMOCK_INCLUDE_DIR)
-    include_directories (
-      ${GTEST_INCLUDE_DIR}
-    )
-  endif(GTEST_INCLUDE_DIR AND GMOCK_INCLUDE_DIR)
-
   add_subdirectory(tests)
-
 else (ENABLE_UNIT_TESTS)
   set (MISSING_TESTS_MSG "-- Tests disabled, compile with -DENABLE_UNIT_TESTS=ON")
   add_custom_target (check COMMAND echo ${MISSING_TESTS_MSG})
@@ -361,46 +312,11 @@
   add_custom_target (gcheck COMMAND echo ${MISSING_TESTS_MSG})
 endif (ENABLE_UNIT_TESTS)
 
-#
-# GSettings Schema
-#
-SET (UNITY_SCHEMAS "com.canonical.Unity.gschema.xml")
-SET (UNITY_TEST_SCHEMAS "external.gschema.xml")
-
-# Have an option to not install the schema into where GLib is
-option (GSETTINGS_LOCALINSTALL "Install GSettings Schemas locally instead of to the GLib prefix" OFF)
-if (GSETTINGS_LOCALINSTALL)
-    SET (GSETTINGS_DIR "${CMAKE_INSTALL_DATADIR}/glib-2.0/schemas/")
-else (GSETTINGS_LOCALINSTALL)
-    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} glib-2.0 --variable prefix  OUTPUT_VARIABLE _glib_prefix OUTPUT_STRIP_TRAILING_WHITESPACE)
-    SET (GSETTINGS_DIR "${_glib_prefix}/share/glib-2.0/schemas/")
-endif (GSETTINGS_LOCALINSTALL)
-
-# Run the validator and error if it fails
-execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} gio-2.0 --variable glib_compile_schemas  OUTPUT_VARIABLE _glib_comple_schemas OUTPUT_STRIP_TRAILING_WHITESPACE)
-execute_process (COMMAND ${_glib_comple_schemas} --dry-run --schema-file=${CMAKE_CURRENT_SOURCE_DIR}/${UNITY_SCHEMAS} ERROR_VARIABLE _schemas_invalid OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-if (_schemas_invalid)
-  message (SEND_ERROR "Schema validation error: ${_schemas_invalid}")
-endif (_schemas_invalid)
-
-# Actually install and recomple schemas
-message (STATUS "GSettings schemas will be installed into ${GSETTINGS_DIR}")
-install (FILES ${UNITY_SCHEMAS} DESTINATION ${GSETTINGS_DIR} OPTIONAL)
-install (CODE "message (STATUS \"Compiling GSettings schemas\")")
-install (CODE "execute_process (COMMAND ${_glib_comple_schemas} ${GSETTINGS_DIR})")
-
 # Resources
 install (FILES resources/dash-widgets.json DESTINATION ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/themes)
 file (GLOB _datafiles "${CMAKE_CURRENT_SOURCE_DIR}/resources/*")
 install (FILES ${_datafiles} DESTINATION ${PKGDATADIR})
 
-
-# For testing
-configure_file (${CMAKE_SOURCE_DIR}/${UNITY_SCHEMAS} ${CMAKE_BINARY_DIR}/settings/${UNITY_SCHEMAS})
-configure_file (${CMAKE_SOURCE_DIR}/tests/data/${UNITY_TEST_SCHEMAS} ${CMAKE_BINARY_DIR}/settings/${UNITY_TEST_SCHEMAS})
-execute_process (COMMAND ${_glib_comple_schemas} ${CMAKE_BINARY_DIR}/settings)
-
 #
 # docs
 #
@@ -426,8 +342,3 @@
 
 endif (DOXYGEN_FOUND STREQUAL "YES")
 
-#
-# Upstart
-#
-configure_file(unity7.conf.in ${CMAKE_CURRENT_BINARY_DIR}/unity7.conf)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/unity7.conf DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
 
=== modified file 'ChangeLog'
--- ChangeLog	2016-05-14 23:01:37 +0000
+++ ChangeLog	2017-12-01 18:43:57 +0000
@@ -1,3 +1,666 @@
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	tools: add migration script to set the default values for unity-lowgfx profile
+	
+	Compiz migration scripts are tricky and non always functional, this is safer
+	and known to work.
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Avoid to show multiple "Authentication Failure" messages.
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Wait until the color buffer is cleared before suspending. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Refactor the way UserAuthenticator is created and passed around. Handle failures to create new threads and fallback to a "Switch to greeter..." button in case of failure. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Tests: split unit tests in single binaries, enable unstable tests
+	
+	Use CMake foo, for getting the best for running tests in single mode
+	and generating smart targets for them
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	CMakeLists.txt: add support to compile with GTest 1.8 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	PanelController: ensure we disconnect from signals on destruction
+	
+	It's just about using the magic of deriving from sigc::trackable.
+	Since UScreen might be late in signaling screen changes it could fail
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	compiz-profile-selector: use initctl properly (it won't pull env var from current config)
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	unity.cmake: avoid setting not existing profiles when gfx tests fail
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	compiz-profile-selector: use ligther syntax for updating env variables
+	
+	And fixes badly set variables in systemd too
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	tests: add org.compiz 'current-profile' to external gsettings
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Launcher: disable or reduce most icon effects on lowgfx 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnitySettings: listen to compiz profile status in order to set low_gfx value
+	
+	Instead of changing this value back and forth multiple times, just wait
+	this to be really changed in compiz, and update our internal variable
+	accordingly.
+	Also take care of the gsettings unity's lowgfx value only if the user has
+	set it.
+	
+	This fixes an infinite loop when starting compiz in a lowgfx environment.
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnitySettings: use glib::Signal blocking for ignoring setting changes
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	GLibSignal: allow to block, unblock signals
+	
+	Added support also to SignalManager, changed a bit the interface
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Lockscreen: always draw the background-color in the lockscreen
+	
+	This is to avoid showing a transparent background if the background file is missing. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	compiz-profile-selector: don't try to update systemd in upstart session
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	BGHash, UnityScreen: get desktop averageColor from compiz
+	
+	compiz now supports getting this value, let's use it instead of
+	doing this again here.
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Use g_mkdir_with_parents instead of mkdir.
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	compiz-profile-setter: tool to update the current profile and use in systemd and Unity settings
+	
+	Added a compiz-profile-setter tool that allows to change compiz profile, so we use
+	this to set the right profile when starting unity and when the gsettings key has changed.
+	
+	So we can just toggle lowgfx profile on the fly by just doing
+	gsettings set com.canonical.Unity lowgfx true|false 
+
[phone]  Eleni Maria Stea  <[e-mail]>
+
+	removes lowgfx option from ccsm, reads the "lowgfx" gsetting (lp:~hikiko/unity-control-center/unity-control-center.lowgfx) 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Unity: Move scripts to tools, using cmake to generate proper paths
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	CMake: move data and setting files in proper folder, define shared libdir variables
+
[phone]  Nick Dedekind  <[e-mail]>
+
+	Fixed tooltip scaling issues. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Panel: ensure the menu-manager tracker is updated to match monitor
+	
+	Also always use an unique name for panel depending on monitor
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	InputMonitor: don't try to deference an invalid Nux display 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnityWindow: safely check validity of UnityWindow from scaled one 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	BackgroundSettings: use gnome-bg to generate textures with proper scaling
+	
+	When using non-user background, we ensure that the texture size matches
+	the screen size, and also we now generate the background using an high
+	quality pixmap, instead of stretching a non-scaled one. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	GnomeSessionManager: add gcancellable to instance and use it for calls with temporary proxies
+	
+	This fixes various crashes when the session manager is destroyed while a temporary proxy
+	call is still in progress, and the callback is called afterwards.
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Keep the screen locked if rebooting with autologin. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Round gtk scaling factor to closest integer. 
+
[phone]  Eleni Maria Stea  <[e-mail]>
+
+	shouldn't create blur rectangles when there's no blur, skips the blur rects processing in low gfx.
+
[phone]  Kai-Heng Feng  <[e-mail]>
+
+	UnitySettings: If scale-factor is not set, find and set right scale for HiDPI displays.
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnityScreen: toggle gestures recognition on lock 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	LauncherOptions: use track_obj to manage option changes 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	LockScreenController: use input monitor to get the events to switch monitor
+	
+	In this way we can safely switch the monitor also on button click (after closing a menu)
+	or when moving over the panel (that wasn't properly handled before). 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	LockScreenController: use InputMonitor to get all the events and hide the Blank Window
+	
+	When the blank window is shown now we use the XI2 events to figure out if we can hide it
+	in this way it will be possible to show the screensaver when something is grabbing the 
+	screen and we don't need to grab the screen anymore to get the events. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	GnomeSession: Retrieve the session id using dbus if c2 is not set
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Correctly position the force quit dialog when scaling is different than 1.0 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Properly handle the file manager copy dialog in FileManagerLauncherIcon and in StorageLauncherIcon. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	LockScreenController: ignore icon_paths_changed signal in menumanager for Lockscreen 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	PanelService: don't allow to deactivate menus if they've been opened too shortly
+	
+	This could be caused by some random events while doing fast scrubbing.
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	PanelView: scale gradient refinement properly
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	MenuManager: add support for mouse trackers with triangle algorithm support
+	
+	It allows to register pointer trackers with menu entries selection by using the triangle
+	technique which prevents menus items from being opened on quick menu scrubbing
+	
+	Then use use menu::Manager pointer tracker for entries activation in PanelView, LockScreenPanel and DecorationsMenuLayout 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	LockScreenPanel: use InputMonitor events instead of mouse polling for menu scrubbing
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	PanelView: use InputMonitor to track menu events
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DecorationsMenuLayout: use input monitor for menu scrubbing 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	EdgeBarrierController: use InputMonitor to get the barrier events instead of relying on its implementation
+	
+	Also disable the input barrier if we don't really need it
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	InputMonitor: add an unity class that monitors XInput2 events and converts them to XEvent
+	
+	Clients of this class can register event handlers, and when an interested event will hit
+	our event filter function (that is set only if we have handlers), then we notify them
+	with a standard XEvent struct, converted from the XIDeviceEvent cookie.
+	
+	The nice thing of this monitor is that it always reports events, despite the X grabs.
+
[phone]  Bileto Bot  <[e-mail]>
+
+	Releasing 7.4.0+16.04.20160906-0ubuntu1
+
[phone]  Bileto Bot  <[e-mail]>
+
+	* SwitcherView: always disable animations when in lowgfx mode (LP:
+	#1602784)
+	* When locked discard damages from windows below lockscreen. (LP:
+	#1605180)
+	* DecoratedWindow: display unmaximize button if the window is
+	vertically or horizontally maximized (LP: #1608480)
+	* Make sure the switcher detail view is properly scaled. Also scale
+	the xy_offset to make sure the switcher and launcher do not overlap.
+	(LP: #1605256)
+	* Close session dialog on first ESC. (LP: #1521116)
+	* Filter out scrolling envents for FilterExpanderLabel. (LP: #1604632)
+	* Disable menu discovery animation if MenusDiscoveryDuration is 0.
+	(LP: #942962)
+	* Redraw fake decorations on window resize. (LP: #940470)
+	* Use compiz::Window::serverNext instead of compiz::Window::next in
+	IsWindowObscured as the latter can be outdated just after
+	scale/spread terminates. (LP: #1614116)
+	* DecoratedWindow: avoid deferencing an invalid shadow texture ptr,
+	and split functions (LP: #1608464)
+	* DecoratedWindow: display unmaximize button if the window is
+	vertically or horizontally maximized (LP: #1608480)
+	* DecorationsForceQuitDialog: make CSS selectors work with gtk 3.20
+	* UserAuthenticatorPam: ensure pam_handle_ is null initialized and
+	don't proceed if not set (LP: #1611668)
+	* DecorationStyle: set css name for Gtk 3.20
+	* OverlayRenderer: properly decorate launcher/panel when the launcher
+	is at the bottom (LP: #1611694)
+	* OverlayRenderer: don't use rotated textures, just rotate them at
+	rendering time
+	* SpreadWidgets: add container for spread filter and new spread
+	decorations (LP: #1283314)
+	* WindowButton: properly partially unmaximize a window when
+	middle/left clicking in the restore button (LP: #1616136)
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	debian/changelog: no bug #1616031 is not sadly fixed here
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Use compiz::Window::serverNext instead of compiz::Window::next in IsWindowObscured as the latter can be outdated just after scale/spread terminates. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	WindowButton: properly partially unmaximize a window when middle/left clicking in the restore button 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Redraw fake decorations on window resize. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Disable menu discovery animation if MenusDiscoveryDuration is 0. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	debian/changelog: add bug #1616031 as fixed too
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	SpreadWidgets: add container for spread filter and new spread decorations
+	
+	Now when windows are spread, launcher and panel aren't "naked" anymore 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	OverlayRenderer: don't use rotated textures, just rotate them at rendering time
+	
+	So removing duplicated data, since we can do this at code level
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	OverlayRenderer: properly decorate launcher/panel when the launcher is at the bottom 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Filter out scrolling envents for FilterExpanderLabel. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	DecorationStyle: set css name for Gtk 3.20
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	UserAuthenticatorPam: ensure pam_handle_ is null initialized and don't proceed if not set 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Close session dialog on first ESC. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Make sure the switcher detail view is properly scaled. Also scale the xy_offset to make sure the switcher and launcher do not overlap. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	DecorationsForceQuitDialog: make CSS selectors work with gtk 3.20
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DecoratedWindow: display unmaximize button if the window is vertically or horizontally maximized
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	DecoratedWindow: avoid deferencing an invalid shadow texture ptr, and split functions 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	When locked discard damages from windows below lockscreen. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	SwitcherView: always disable animations when in lowgfx mode 
+
[phone]  Bileto Bot  <[e-mail]>
+
+	Releasing 7.4.0+16.04.20160801.2-0ubuntu1
+
[phone]  Bileto Bot  <[e-mail]>
+
+	* FileManagerLauncherIcon: Don't trust the Quirk::VISIBLE in the ctor.
+	(LP: #1599133)
+	* [TrashLauncherIcon] Create GFileMonitor in an idle to avoid blocking
+	calls. (LP: #1602720)
+	* [LockSceen] Remove numlock warning. (LP: #1526322)
+	* Make sure initiate and terminate callbacks are not empty before
+	calling them. (LP: #1605012)
+	* Properly destroy close_button_ to properly disconnect lambda. (LP:
+	#1605010)
+	* Use the standard notification-device-eject in the "device eject"
+	notification. This allows us to scale it properly on high-dpi
+	setups. (LP: #1605231)
+	* Add tools to enforce unityshell plugin for the current profile and
+	add "move" and "resize" plugins as requirements. (LP: #1506023, LP:
+	#1605007, LP: #1604657)
+	* Unity script: use result from unity_support_test to check the right
+	COMPIZ_CONFIG_PROFILE to use (LP: #1602377)
+	* LockScreenAcceleratorController: ensure callbacks are valid before
+	calling them (LP: #1605012)
+	* DecoratedWindow: Added shadows for shaped windows (LP: 1608418)
+	* DecoratedWindow: Cleanup shadows for shaped windows, reduce
+	recomputation (LP: #1608418)
+	* UnityWindowView: don't try to deference close_button_ if its' null
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DecoratedWindow: split shadow quads computation based on shaped window state
+	
+	And reset textures on change
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	CompizUtils: add add flag to decoration utils for shaped windows
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DecoratedWindow: avoid deferencing an invalid shadow texture ptr, and split functions
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnityWindowView: don't try to deference close_button_ if its' null
+	
+	It could happen when manually triggering a signal
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DecoratedWindow: Cleanup shadows for shaped windows, reduce recomputation
+
[phone]  Eleni Maria Stea  <[e-mail]> 
+
+	DecoratedWindow: Added shadows for shaped windows
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	LockScreenAcceleratorController: ensure callbacks are valid before calling them 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Add tools to enforce unityshell plugin for the current profile and add "move" and "resize" plugins as requirements.
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Use the standard notification-device-eject in the "device eject" notification. This allows us to scale it properly on high-dpi setups. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Properly destroy close_button_ to properly disconnect lambda. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Make sure initiate and terminate callbacks are not empty before calling them. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	[LockSceen] Remove numlock warning. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	Unity script: use result from unity_support_test to check the right COMPIZ_CONFIG_PROFILE to use 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	[TrashLauncherIcon] Create GFileMonitor in an idle to avoid blocking calls. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	FileManagerLauncherIcon: Don't trust the Quirk::VISIBLE in the ctor.
+	
+	Make sure a window is valid/mapped before considering it a manager storage window. 
+
[phone]  Bileto Bot  <[e-mail]>
+
+	Releasing 7.4.0+16.04.20160715-0ubuntu1
+
[phone]  Bileto Bot  <[e-mail]>
+
+	* PanelView: Don't draw it if the geo doesn't intersect the monitor
+	geo (as in ezoom)
+	* speeds up the showdesktop plugin in lowgfx mode
+	* Add whitelist for auto-repated keys. (LP: #1586491)
+	* Fix scale window activation if in show desktop mode. (LP: #1582056)
+	* Order matters in the rendering. Draw launcher shadow after the
+	background in all cases. (LP: #1586374)
+	* Fallback to volume name if no other identifier is available. (LP:
+	#1103593)
+	* Do not trigger screensaver on session inactive. (LP: #1587507)
+	* Use SwitcherController::SetDetail instead of detail=... (LP:
+	#1587618)
+	* UnitySettings: Add an option to enable/disable pam account checking.
+	(LP: #1460649)
+	* Lockscreen: Make sure warning and errors are properly shown to the
+	user (LP: #1593696)
+	* Add missing header to fix compilation error with -Duse_pch=OFF.
+	* Filter out fullscreen window in show desktop mode. (LP: #1597706)
+	* Make sure file manager icon is not removed when unpinned. (LP:
+	#1578792)
+	* Properly calculate the intersection geometry in PanelView::Draw.
+	This is needed to properly call SyncGeometries and to avoid problems
+	such as lp:1595698. (LP: #1595698)
+	* UnitySettings: Add dconf keys for disabling multitouch gestures (LP:
+	#1589520)
+	* LockScreenAcceleratorController: use key::Grabber to handle allowed
+	bindings (LP: #1438754)
+	* LockScreenAcceleratorController: check if a setting key is available
+	instead of crashing
+	* ApplicationLauncherIcon: ensure quirks are properly set on icon
+	initialization
+	* Views: Toggle animators durations based on low-gfx setting (LP:
+	#1598770)
+	* unity7.conf: use different compiz profile based on
+	unity_support_test result (LP: #1598770)
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	unity7.conf: use different compiz profile based on unity_support_test result 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	Views: Toggle animators durations based on low-gfx setting
+	
+	Disable animations based on low_gfx setting (now ported to nux::Property) 
+
[phone]  Eleni Maria Stea  <[e-mail]> 
+
+	speeds up the showdesktop plugin in lowgfx mode
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	ApplicationLauncherIcon: ensure quirks are properly set on icon initialization
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	LockScreenAcceleratorController: check if a setting key is available instead of crashing
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Properly calculate the intersection geometry in PanelView::Draw. This is needed to properly call SyncGeometries and to avoid problems such as lp:1595698. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Make sure file manager icon is not removed when unpinned. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Filter out fullscreen window in show desktop mode.
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Add missing header to fix compilation error with -Duse_pch=OFF.
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	debian/changelog: fix author
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Lockscreen: Make sure warning and errors are properly shown to the user 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	UnitySettings: Add an option to enable/disable pam account checking. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]> 
+
+	LockScreenAcceleratorController: use key::Grabber to handle allowed bindings This makes U-S-D to handle key events, without having to add some extra custom code inside the lockscreen. It's all just about whitelisting the wanted values. 
+
[phone]  Alberto Milone  <[e-mail]> 
+
+	UnitySettings: Add dconf keys for disabling multitouch gestures 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Use SwitcherController::SetDetail instead of detail=... 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Do not trigger screensaver on session inactive. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Fallback to volume name if no other identifier is available. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Order matters in the rendering. Draw launcher shadow after the background in all cases. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Fix scale window activation if in show desktop mode. 
+
[phone]  Andrea Azzarone  <[e-mail]> 
+
+	Add whitelist for auto-repated keys. 
+
[phone]  Eleni Maria Stea  <[e-mail]>
+
+	PanelView: Don't draw it if the geo doesn't intersect the monitor geo (as in ezoom) added check to see if the panel geometry intersects the geometry of the monitor the panel belongs to. If there's no intersection there's no need to draw it (return). If there is intersection we should only draw the intersection area (clip the non visible parts).
+
[phone]  CI Train Bot  <[e-mail]>
+
+	Releasing 7.4.0+16.04.20160526.1-0ubuntu1
+
[phone]  handsome_feng  <[e-mail]>
+
+	Releasing unity SRU1 for Xenial Fixes: #1525685, #1553165, #1562348, #1562847, #1570843, #1572241, #1573897, #1574689, #1575527, #1580211, #1580212
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	debian/changelog: set proper version manually
+
[phone]  handsome_feng  <[e-mail]>
+
+	Change the x_offset of expo when launcher position changed. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	DashStyle: ensure LazyLoadTexture disconnects from signals on destruction 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	SwitcherController: don't try to get a window from empty selections 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	UnityScreen, UnityWindow: cleanup a little the code, and ensure overridden CompositeWindow functions get actually called There would be still a lot to do in this scenario, but still a start...F
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	SwitcherView: close the mouse-selected application on middle-click 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Do not reset the shortcut for icons that have their own shortcut. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Fallback to background class in case no background is specified for title bars and top panel. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Properly calculate array indexes to avoid crashes. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	GnomeKeyGrabber: do not activate an action if it's a repeated one. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Update ExpoLauncherIcon in case the quicklist is used to switch vp. 
+
[phone]  Andrea Azzarone  <[e-mail]>
+
+	Properly remove SoftwareCenterLauncherIcon in case of failure. 
+
[phone]  Marco Trevisan (Treviño)  <[e-mail]>
+
+	Releasing Unity 7.4.0
+
 2016-04-15  CI Train Bot  <[e-mail]>
 
 	Releasing 7.4.0+16.04.20160415-0ubuntu1
 
=== modified file 'UnityCore/CMakeLists.txt'
--- UnityCore/CMakeLists.txt	2016-02-09 01:26:22 +0000
+++ UnityCore/CMakeLists.txt	2017-12-01 18:43:57 +0000
@@ -145,7 +145,8 @@
 set_target_properties(${CORE_LIB_NAME} PROPERTIES
                       VERSION ${CORE_LIB_LT_CURRENT}.${CORE_LIB_LT_REV}.${CORE_LIB_LT_AGE}
                       SOVERSION ${CORE_LIB_LT_CURRENT}
-                      INSTALL_RPATH "${PRIVATE_CORE_DEPS_LIBRARY_DIRS}")
+                      INSTALL_RPATH "${PRIVATE_CORE_DEPS_LIBRARY_DIRS}"
+                      BUILD_WITH_INSTALL_RPATH TRUE)
 add_pch(pch/unitycore_pch.hh ${CORE_LIB_NAME})
 
 install (TARGETS ${CORE_LIB_NAME}
 
=== modified file 'UnityCore/DBusIndicators.cpp'
--- UnityCore/DBusIndicators.cpp	2016-02-09 01:26:22 +0000
+++ UnityCore/DBusIndicators.cpp	2017-12-01 18:43:57 +0000
@@ -123,7 +123,7 @@
 
     // This is obviously hackish, but this part of the code is mostly hackish...
     // Let's attempt to run it from where we expect it to be
-    std::string cmd = UNITYLIBDIR"/" + std::string("unity-panel-service");
+    std::string cmd = UNITY_LIBDIR"/" + std::string("unity-panel-service");
     LOG_WARN(logger) << "Couldn't load panel from installed services, "
                      << "so trying to load panel from known location: " << cmd;
 
 
=== modified file 'UnityCore/GLibDBusProxy.cpp'
--- UnityCore/GLibDBusProxy.cpp	2015-11-24 16:40:03 +0000
+++ UnityCore/GLibDBusProxy.cpp	2017-12-01 18:43:57 +0000
@@ -609,7 +609,7 @@
   return nullptr;
 }
 
-void DBusProxy::GetProperty(std::string const& name, ReplyCallback const& callback)
+void DBusProxy::GetProperty(std::string const& name, ReplyCallback const& callback, GCancellable *cancellable)
 {
   if (!callback)
     return;
@@ -620,7 +620,8 @@
                            pimpl->name_.c_str(), pimpl->object_path_.c_str(),
                            "org.freedesktop.DBus.Properties",
                            "Get", g_variant_new ("(ss)", pimpl->interface_name_.c_str(), name.c_str()),
-                            G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, -1, pimpl->cancellable_,
+                            G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, -1,
+                            cancellable ? cancellable : pimpl->cancellable_,
                            [] (GObject *source, GAsyncResult *res, gpointer user_data) {
       glib::Error err;
       std::unique_ptr<ReplyCallback> callback(static_cast<ReplyCallback*>(user_data));
@@ -641,15 +642,16 @@
   else
   {
     // This will get the property as soon as we have a connection
+    glib::Object<GCancellable> canc(cancellable, AddRef());
     auto conn = std::make_shared<sigc::connection>();
-    *conn = connected.connect([this, conn, name, callback] {
-      GetProperty(name, callback);
+    *conn = connected.connect([this, conn, name, callback, canc] {
+      GetProperty(name, callback, canc);
       conn->disconnect();
     });
   }
 }
 
-void DBusProxy::SetProperty(std::string const& name, GVariant* value)
+void DBusProxy::SetProperty(std::string const& name, GVariant* value, GCancellable *cancellable)
 {
   if (IsConnected())
   {
@@ -657,7 +659,8 @@
                            pimpl->name_.c_str(), pimpl->object_path_.c_str(),
                            "org.freedesktop.DBus.Properties",
                            "Set", g_variant_new ("(ssv)", pimpl->interface_name_.c_str(), name.c_str(), value),
-                           nullptr, G_DBUS_CALL_FLAGS_NONE, -1, pimpl->cancellable_,
+                           nullptr, G_DBUS_CALL_FLAGS_NONE, -1,
+                           cancellable ? cancellable : pimpl->cancellable_,
                            [] (GObject *source, GAsyncResult *res, gpointer user_data) {
       glib::Error err;
       Variant result(g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &err), StealRef());
@@ -670,9 +673,10 @@
   else
   {
     // This will set the property as soon as we have a connection
+    glib::Object<GCancellable> canc(cancellable, AddRef());
     auto conn = std::make_shared<sigc::connection>();
-    *conn = connected.connect([this, conn, name, value] {
-      SetProperty(name, value);
+    *conn = connected.connect([this, conn, name, value, canc] {
+      SetProperty(name, value, canc);
       conn->disconnect();
     });
   }
 
=== modified file 'UnityCore/GLibDBusProxy.h'
--- UnityCore/GLibDBusProxy.h	2014-10-10 11:35:40 +0000
+++ UnityCore/GLibDBusProxy.h	2017-12-01 18:43:57 +0000
@@ -74,8 +74,8 @@
   bool IsConnected() const;
 
   Variant GetProperty(std::string const& property_name) const;
-  void GetProperty(std::string const& property_name, ReplyCallback const&);
-  void SetProperty(std::string const& property_name, GVariant* value);
+  void GetProperty(std::string const& property_name, ReplyCallback const&, GCancellable *cancellable = nullptr);
+  void SetProperty(std::string const& property_name, GVariant* value, GCancellable *cancellable = nullptr);
 
   void Connect(std::string const& signal_name, ReplyCallback const& callback);
   void DisconnectSignal(std::string const& signal_name = "");
 
=== modified file 'UnityCore/GLibSignal-inl.h'
--- UnityCore/GLibSignal-inl.h	2014-10-15 05:16:46 +0000
+++ UnityCore/GLibSignal-inl.h	2017-12-01 18:43:57 +0000
@@ -34,11 +34,11 @@
 }
 
 template <typename R, typename G, typename... Ts>
-void Signal<R, G, Ts...>::Connect(G object, std::string const& signal_name,
+bool Signal<R, G, Ts...>::Connect(G object, std::string const& signal_name,
                                   SignalCallback const& callback)
 {
   if (!callback || !G_IS_OBJECT(object) || signal_name.empty())
-    return;
+    return false;
 
   Disconnect();
 
@@ -47,6 +47,8 @@
   callback_ = callback;
   connection_id_ = g_signal_connect(object_, signal_name.c_str(), G_CALLBACK(Callback), this);
   g_object_add_weak_pointer(object_, reinterpret_cast<gpointer*>(&object_));
+
+  return true;
 }
 
 template <typename R, typename G, typename... Ts>
@@ -59,6 +61,12 @@
   return R();
 }
 
+template <typename R, typename G, typename... Ts>
+SignalBase::Ptr SignalManager::Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const& callback)
+{
+  return Add(std::make_shared<Signal<R, G, Ts...>>(object, signal_name, callback));
+}
+
 }
 }
 
 
=== modified file 'UnityCore/GLibSignal.cpp'
--- UnityCore/GLibSignal.cpp	2012-08-15 16:58:14 +0000
+++ UnityCore/GLibSignal.cpp	2017-12-01 18:43:57 +0000
@@ -35,16 +35,46 @@
   Disconnect();
 }
 
-void SignalBase::Disconnect()
+bool SignalBase::Disconnect()
 {
+  bool disconnected = false;
+
   if (connection_id_ && G_IS_OBJECT(object_))
   {
     g_signal_handler_disconnect(object_, connection_id_);
     g_object_remove_weak_pointer(object_, reinterpret_cast<gpointer*>(&object_));
+    disconnected = true;
   }
 
   object_ = nullptr;
   connection_id_ = 0;
+  return disconnected;
+}
+
+bool SignalBase::Block() const
+{
+  bool blocked = false;
+
+  if (connection_id_ && G_IS_OBJECT(object_))
+  {
+    g_signal_handler_block(object_, connection_id_);
+    blocked = true;
+  }
+
+  return blocked;
+}
+
+bool SignalBase::Unblock() const
+{
+  bool unblocked = false;
+
+  if (connection_id_ && G_IS_OBJECT(object_))
+  {
+    g_signal_handler_unblock(object_, connection_id_);
+    unblocked = true;
+  }
+
+  return unblocked;
 }
 
 GObject* SignalBase::object() const
@@ -75,57 +105,73 @@
 // was too messy to try and write a copy constructor/operator that would steal
 // from "other" and make the new one the owner. Not only did it create
 // opportunity for random bugs, it also made the API bad.
-void SignalManager::Add(SignalBase* signal)
+SignalBase::Ptr SignalManager::Add(SignalBase* signal)
 {
-  Add(SignalBase::Ptr(signal));
+  return Add(SignalBase::Ptr(signal));
 }
 
-void SignalManager::Add(SignalBase::Ptr const& signal)
+SignalBase::Ptr SignalManager::Add(SignalBase::Ptr const& signal)
 {
   connections_.push_back(signal);
   g_object_weak_ref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
-}
-
-void SignalManager::OnObjectDestroyed(SignalManager* self, GObject* old_obj)
-{
-  for (auto it = self->connections_.begin(); it != self->connections_.end();)
-  {
-    auto const& signal = *it;
-
-    // When an object has been destroyed, the signal member is nullified,
-    // so at this point we can be sure that removing signal with a null object,
-    // means removing invalid signals.
-    if (!signal->object())
-    {
-      it = self->connections_.erase(it);
-    }
-    else
-    {
-      ++it;
-    }
-  }
+  return signal;
 }
 
 // This uses void* to keep in line with the g_signal* functions
 // (it allows you to pass in a GObject without casting up).
-void SignalManager::Disconnect(void* object, std::string const& signal_name)
+bool SignalManager::ForeachMatchedSignal(void* object, std::string const& signal_name, std::function<void(SignalBase::Ptr const&)> action, bool erase_after)
 {
-  bool all_signals = signal_name.empty();
+  bool action_performed = false;
+  bool all_objects = (object == reinterpret_cast<void*>(std::numeric_limits<uintptr_t>::max()));
+  bool all_signals = all_objects || signal_name.empty();
 
   for (auto it = connections_.begin(); it != connections_.end();)
   {
     auto const& signal = *it;
 
-    if (signal->object() == object && (all_signals || signal->name() == signal_name))
+    if ((all_objects || signal->object() == object) && (all_signals || signal->name() == signal_name))
     {
-      g_object_weak_unref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
-      it = connections_.erase(it);
+      if (action)
+      {
+        action_performed = true;
+        action(signal);
+      }
+
+      it = erase_after ? connections_.erase(it) : ++it;
     }
     else
     {
       ++it;
     }
   }
+
+  return action_performed;
+}
+
+void SignalManager::OnObjectDestroyed(SignalManager* self, GObject* old_obj)
+{
+  self->ForeachMatchedSignal(nullptr, "", nullptr, /*erase_after*/ true);
+}
+
+bool SignalManager::Block(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    signal->Block();
+  });
+}
+
+bool SignalManager::Unblock(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    signal->Unblock();
+  });
+}
+
+bool SignalManager::Disconnect(void* object, std::string const& signal_name)
+{
+  return ForeachMatchedSignal(object, signal_name, [this] (SignalBase::Ptr const& signal) {
+    g_object_weak_unref(signal->object(), (GWeakNotify)&OnObjectDestroyed, this);
+  }, true);
 }
 
 }
 
=== modified file 'UnityCore/GLibSignal.h'
--- UnityCore/GLibSignal.h	2012-08-15 16:58:14 +0000
+++ UnityCore/GLibSignal.h	2017-12-01 18:43:57 +0000
@@ -21,6 +21,7 @@
 #ifndef UNITY_GLIB_SIGNAL_H
 #define UNITY_GLIB_SIGNAL_H
 
+#include <limits>
 #include <string>
 #include <vector>
 #include <memory>
@@ -39,7 +40,10 @@
 
   virtual ~SignalBase();
 
-  void Disconnect();
+  bool Disconnect();
+
+  bool Block() const;
+  bool Unblock() const;
 
   GObject* object() const;
   std::string const& name() const;
@@ -71,9 +75,9 @@
 #endif
 
   inline Signal() {};
-  inline Signal(G object, std::string const& signal_name, SignalCallback const& callback);
+  inline Signal(G object, std::string const& signal_name, SignalCallback const&);
 
-  inline void Connect(G Object, std::string const& signal_name, SignalCallback const& callback);
+  inline bool Connect(G Object, std::string const& signal_name, SignalCallback const&);
 
 private:
   static R Callback(G Object, Ts... vs, Signal* self);
@@ -86,17 +90,18 @@
 public:
   SignalManager();
   ~SignalManager();
-  void Add(SignalBase* signal);
-  void Add(SignalBase::Ptr const& signal);
+  SignalBase::Ptr Add(SignalBase* signal);
+  SignalBase::Ptr Add(SignalBase::Ptr const& signal);
   template <typename R, typename G, typename... Ts>
-  void Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const& callback)
-  {
-    Add(std::make_shared<Signal<R, G, Ts...>>(object, signal_name, callback));
-  }
-
-  void Disconnect(void* object, std::string const& signal_name = "");
+  SignalBase::Ptr Add(G object, std::string const& signal_name, typename Signal<R, G, Ts...>::SignalCallback const&);
+
+  bool Block(void* object = (void*) std::numeric_limits<uintptr_t>::max(), std::string const& signal_name = "");
+  bool Unblock(void* object = (void*) std::numeric_limits<uintptr_t>::max(), std::string const& signal_name = "");
+
+  bool Disconnect(void* object, std::string const& signal_name = "");
 
 private:
+  bool ForeachMatchedSignal(void* object, std::string const& signal_name, std::function<void(SignalBase::Ptr const&)> action, bool erase_after = false);
   static void OnObjectDestroyed(SignalManager* self, GObject* old_obj);
 
 protected:
 
=== modified file 'UnityCore/GnomeSessionManager.cpp'
--- UnityCore/GnomeSessionManager.cpp	2016-06-06 14:28:04 +0000
+++ UnityCore/GnomeSessionManager.cpp	2017-12-01 18:43:57 +0000
@@ -77,6 +77,8 @@
 
 const std::string GNOME_LOCKDOWN_OPTIONS = "org.gnome.desktop.lockdown";
 const std::string DISABLE_LOCKSCREEN_KEY = "disable-lock-screen";
+
+GDBusProxyFlags DEFAULT_CALL_FLAGS = static_cast<GDBusProxyFlags>(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES|G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS|G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION);
 }
 
 GnomeManager::Impl::Impl(GnomeManager* manager, bool test_mode)
@@ -99,38 +101,45 @@
   });
 
   {
-    const char* session_id = test_mode_ ? "id0" : g_getenv("XDG_SESSION_ID");
-
-    login_proxy_ = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.login1",
-                                                     "/org/freedesktop/login1/session/" + glib::gchar_to_string(session_id),
-                                                     "org.freedesktop.login1.Session",
-                                                     test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
-                                                     G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES);
-
-    login_proxy_->Connect("Lock", [this](GVariant*){
-      manager_->PromptLockScreen();
-    });
-
-    login_proxy_->Connect("Unlock", [this](GVariant*){
-      manager_->unlock_requested.emit();
-    });
-
-    login_proxy_->ConnectProperty("Active", [this] (GVariant* variant) {
-      bool active = glib::Variant(variant).GetBool();
-      manager_->is_session_active.changed.emit(active);
-      if (active)
-        manager_->screensaver_requested.emit(false);
-    });
-
-    manager_->is_session_active.SetGetterFunction([this] {
-      return login_proxy_->GetProperty("Active").GetBool();
-    });
+    std::string session_id = test_mode_ ? "id0" : glib::gchar_to_string(g_getenv("XDG_SESSION_ID"));
+
+    if (!session_id.empty())
+    {
+      CallLogindMethod("GetSession", g_variant_new("(s)", session_id.c_str()), [this, session_id] (GVariant* variant, glib::Error const& err) {
+        std::string session_path;
+
+        if (!err && variant)
+          session_path = glib::Variant(variant).GetObjectPath();
+
+        if (session_path.empty())
+          session_path = "/org/freedesktop/login1/session/" + session_id;
+
+        SetupLogin1Proxy(session_path);
+      });
+    }
+    else
+    {
+      auto proxy = std::make_shared<glib::DBusProxy>("org.freedesktop.login1",
+                                                     "/org/freedesktop/login1/user/self",
+                                                     "org.freedesktop.login1.User",
+                                                     G_BUS_TYPE_SYSTEM);
+
+      proxy->GetProperty("Display", [this, proxy] (GVariant *variant) {
+        if (!variant || g_variant_n_children(variant) < 2)
+          return;
+
+        glib::Variant tmp(g_variant_get_child_value(variant, 1), glib::StealRef());
+        SetupLogin1Proxy(tmp.GetObjectPath());
+      }, cancellable_);
+    }
   }
 
   {
     presence_proxy_ = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.gnome.SessionManager",
                                                         "/org/gnome/SessionManager/Presence",
-                                                        "org.gnome.SessionManager.Presence");
+                                                        "org.gnome.SessionManager.Presence",
+                                                        G_BUS_TYPE_SESSION,
+                                                        G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES);
 
     presence_proxy_->Connect("StatusChanged", [this](GVariant* variant) {
       enum class PresenceStatus : unsigned
@@ -166,7 +175,8 @@
     dm_seat_proxy_ = std::make_shared<glib::DBusProxy>("org.freedesktop.Accounts",
                                                        ("/org/freedesktop/Accounts/User" + std::to_string(getuid())).c_str(),
                                                        "org.freedesktop.Accounts.User",
-                                                       G_BUS_TYPE_SYSTEM);
+                                                       G_BUS_TYPE_SYSTEM,
+                                                       G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS);
   }
 
   CallLogindMethod("CanHibernate", nullptr, [this] (GVariant* variant, glib::Error const& err) {
@@ -216,6 +226,34 @@
   ClosedDialog();
 }
 
+void GnomeManager::Impl::SetupLogin1Proxy(std::string const& session_path)
+{
+  login_proxy_ = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.login1",
+                                                   session_path,
+                                                   "org.freedesktop.login1.Session",
+                                                   test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                   G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES);
+
+  login_proxy_->Connect("Lock", [this](GVariant*){
+    manager_->PromptLockScreen();
+  });
+
+  login_proxy_->Connect("Unlock", [this](GVariant*){
+    manager_->unlock_requested.emit();
+  });
+
+  login_proxy_->ConnectProperty("Active", [this] (GVariant* variant) {
+    bool active = glib::Variant(variant).GetBool();
+    manager_->is_session_active.changed.emit(active);
+    if (active)
+      manager_->screensaver_requested.emit(false);
+  });
+
+  manager_->is_session_active.SetGetterFunction([this] {
+    return login_proxy_->GetProperty("Active").GetBool();
+  });
+}
+
 bool GnomeManager::Impl::InteractiveMode()
 {
   bool schema_found = false;
@@ -374,7 +412,8 @@
                                                 glib::DBusProxy::CallFinishedCallback const& cb)
 {
   auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.gnome.SessionManager",
-                                                 "/org/gnome/SessionManager", "org.gnome.SessionManager");
+                                                 "/org/gnome/SessionManager", "org.gnome.SessionManager",
+                                                 G_BUS_TYPE_SESSION, DEFAULT_CALL_FLAGS);
 
   // By passing the proxy to the lambda we ensure that it will be smartly handled
   proxy->CallBegin(method, parameters, [proxy, cb] (GVariant* ret, glib::Error const& e) {
@@ -385,14 +424,15 @@
 
     if (cb)
       cb(ret, e);
-  });
+  }, cancellable_);
 }
 
 void GnomeManager::Impl::CallUPowerMethod(std::string const& method, glib::DBusProxy::ReplyCallback const& cb)
 {
   auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.UPower",
                                                  "/org/freedesktop/UPower", "org.freedesktop.UPower",
-                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM);
+                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                 DEFAULT_CALL_FLAGS);
 
   proxy->CallBegin(method, nullptr, [proxy, cb] (GVariant *ret, glib::Error const& e) {
     if (e)
@@ -403,7 +443,7 @@
     {
       cb(ret);
     }
-  });
+  }, cancellable_);
 }
 
 void GnomeManager::Impl::CallLogindMethod(std::string const& method, GVariant* parameters, glib::DBusProxy::CallFinishedCallback const& cb)
@@ -411,7 +451,8 @@
   auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.login1",
                                                  "/org/freedesktop/login1",
                                                  "org.freedesktop.login1.Manager",
-                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM);
+                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                 DEFAULT_CALL_FLAGS);
 
   // By passing the proxy to the lambda we ensure that it will be smartly handled
   proxy->CallBegin(method, parameters, [proxy, cb, method] (GVariant* ret, glib::Error const& e) {
@@ -424,7 +465,7 @@
     {
       cb(ret, e);
     }
-  });
+  }, cancellable_);
 }
 
 void GnomeManager::Impl::CallConsoleKitMethod(std::string const& method, GVariant* parameters)
@@ -432,7 +473,8 @@
   auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.ConsoleKit",
                                                  "/org/freedesktop/ConsoleKit/Manager",
                                                  "org.freedesktop.ConsoleKit.Manager",
-                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM);
+                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                 DEFAULT_CALL_FLAGS);
 
   // By passing the proxy to the lambda we ensure that it will be smartly handled
   proxy->CallBegin(method, parameters, [this, proxy] (GVariant*, glib::Error const& e) {
@@ -440,7 +482,7 @@
     {
       LOG_ERROR(logger) << "Fallback call failed: " << e.Message();
     }
-  });
+  }, cancellable_);
 }
 
 void GnomeManager::Impl::CallDisplayManagerSeatMethod(std::string const& method, GVariant* parameters)
@@ -450,13 +492,14 @@
   auto proxy = std::make_shared<glib::DBusProxy>(test_mode_ ? testing::DBUS_NAME : "org.freedesktop.DisplayManager",
                                                  glib::gchar_to_string(xdg_seat_path),
                                                  "org.freedesktop.DisplayManager.Seat",
-                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM);
+                                                 test_mode_ ? G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
+                                                 DEFAULT_CALL_FLAGS);
   proxy->CallBegin(method, parameters, [this, proxy] (GVariant*, glib::Error const& e) {
     if (e)
     {
       LOG_ERROR(logger) << "DisplayManager Seat call failed: " << e.Message();
     }
-  });
+  }, cancellable_);
 }
 
 void GnomeManager::Impl::LockScreen(bool prompt)
@@ -509,7 +552,7 @@
   glib::Variant inhibitors(g_dbus_connection_call_sync(bus, test_mode_ ? testing::DBUS_NAME.c_str() : "org.gnome.SessionManager",
                                                        "/org/gnome/SessionManager", "org.gnome.SessionManager",
                                                        "IsInhibited", g_variant_new("(u)", Inhibited::LOGOUT), nullptr,
-                                                       G_DBUS_CALL_FLAGS_NONE, 500, nullptr, &error));
+                                                       G_DBUS_CALL_FLAGS_NONE, 500, cancellable_, &error));
 
   if (error)
   {
@@ -532,13 +575,53 @@
   auto group = getgrnam(group_name.c_str());
 
   if (group && group->gr_mem)
+  {
     for (int i = 0; group->gr_mem[i]; ++i)
+    {
       if (g_strcmp0(group->gr_mem[i], user_name.c_str()) == 0)
         return true;
+    }
+  }
 
   return false;
 }
 
+bool GnomeManager::Impl::AutomaticLogin()
+{
+  glib::Error error;
+  glib::Object<GDBusConnection> bus(g_bus_get_sync(G_BUS_TYPE_SYSTEM, nullptr, &error));
+
+  if (error)
+  {
+    LOG_ERROR(logger) << "Impossible to get the system bus to know if auto-login is enabled: " << error;
+    return false;
+  }
+
+  glib::Variant user_path(g_dbus_connection_call_sync(bus, "org.freedesktop.Accounts",
+                                                      "/org/freedesktop/Accounts", "org.freedesktop.Accounts",
+                                                      "FindUserByName", g_variant_new("(s)",g_get_user_name()), nullptr,
+                                                      G_DBUS_CALL_FLAGS_NONE, 500, cancellable_, &error));
+
+  if (error)
+  {
+    LOG_ERROR(logger) << "Impossible to get the user path: " << error;
+    return false;
+  }
+
+  glib::Variant autologin(g_dbus_connection_call_sync(bus, "org.freedesktop.Accounts",
+                                                      user_path.GetObjectPath().c_str(), "org.freedesktop.DBus.Properties",
+                                                      "Get", g_variant_new("(ss)", "org.freedesktop.Accounts.User", "AutomaticLogin"), nullptr,
+                                                      G_DBUS_CALL_FLAGS_NONE, 500, cancellable_, &error));
+
+  if (error)
+  {
+    LOG_ERROR(logger) << "Impossible to get the AutomaticLogin property: " << error;
+    return false;
+  }
+
+  return autologin.GetBool();
+}
+
 // Public implementation
 
 GnomeManager::GnomeManager()
@@ -577,6 +660,11 @@
   impl_->UserIconFile(callback);
 }
 
+bool GnomeManager::AutomaticLogin() const
+{
+  return impl_->AutomaticLogin();
+}
+
 void GnomeManager::ScreenSaverActivate()
 {
   screensaver_requested.emit(true);
 
=== modified file 'UnityCore/GnomeSessionManager.h'
--- UnityCore/GnomeSessionManager.h	2015-12-03 05:57:00 +0000
+++ UnityCore/GnomeSessionManager.h	2017-12-01 18:43:57 +0000
@@ -37,6 +37,7 @@
   std::string UserName() const;
   std::string HostName() const;
   void UserIconFile(std::function<void(std::string const&)> const&) const;
+  bool AutomaticLogin() const;
 
   void ScreenSaverActivate();
   void ScreenSaverDeactivate();
 
=== modified file 'UnityCore/GnomeSessionManagerImpl.h'
--- UnityCore/GnomeSessionManagerImpl.h	2015-12-03 05:57:00 +0000
+++ UnityCore/GnomeSessionManagerImpl.h	2017-12-01 18:43:57 +0000
@@ -46,6 +46,8 @@
   Impl(GnomeManager* parent, bool test_mode = false);
   ~Impl();
 
+  void SetupLogin1Proxy(std::string const& session_path);
+
   void ConfirmLogout();
   void ConfirmReboot();
   void ConfirmShutdown();
@@ -67,6 +69,7 @@
   void UpdateHaveOtherOpenSessions();
 
   bool IsUserInGroup(std::string const& user_name, std::string const& group_name);
+  bool AutomaticLogin();
 
   GnomeManager* manager_;
   bool test_mode_;
@@ -82,6 +85,7 @@
   glib::DBusProxy::Ptr dm_proxy_;
   glib::DBusProxy::Ptr dm_seat_proxy_;
 
+  glib::Cancellable cancellable_;
   int open_sessions_;
 };
 
 
=== modified file 'UnityCore/SessionManager.h'
--- UnityCore/SessionManager.h	2016-03-31 09:51:33 +0000
+++ UnityCore/SessionManager.h	2017-12-01 18:43:57 +0000
@@ -46,6 +46,7 @@
   virtual std::string UserName() const = 0;
   virtual std::string HostName() const = 0;
   virtual void UserIconFile(std::function<void(std::string const&)> const&) const = 0;
+  virtual bool AutomaticLogin() const = 0;
 
   virtual void ScreenSaverActivate() = 0;
   virtual void ScreenSaverDeactivate() = 0;
 
=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.cpp	2017-12-01 18:43:57 +0000
@@ -174,6 +174,36 @@
   return result ? result : "";
 }
 
+std::string Variant::GetObjectPath() const
+{
+  const gchar *result = nullptr;
+
+  if (!variant_)
+    return "";
+
+  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_OBJECT_PATH))
+  {
+    // g_variant_get_string doesn't duplicate the string
+    result = g_variant_get_string(variant_, nullptr);
+  }
+  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(o)")))
+  {
+    // As we're using the '&' prefix we don't need to free the string!
+    g_variant_get(variant_, "(&o)", &result);
+  }
+  else
+  {
+    auto const& variant = get_variant(variant_);
+    if (variant)
+      return variant.GetObjectPath();
+
+    LOG_ERROR(logger) << "You're trying to extract a 'o' from a variant which is of type '"
+                      << g_variant_type_peek_string(g_variant_get_type(variant_)) << "'";
+  }
+
+  return result ? result : "";
+}
+
 template <typename TYPE, typename GTYPE>
 TYPE get_numeric_value(GVariant *variant_, const char *type_str, const char *fallback_type_str)
 {
 
=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2013-11-19 20:28:13 +0000
+++ UnityCore/Variant.h	2017-12-01 18:43:57 +0000
@@ -68,6 +68,7 @@
   ~Variant();
 
   std::string GetString() const;
+  std::string GetObjectPath() const;
   unsigned char GetByte() const;
   int16_t GetInt16() const;
   uint16_t GetUInt16() const;
 
=== modified file 'config.h.cmake'
--- config.h.cmake	2016-02-09 01:26:22 +0000
+++ config.h.cmake	2017-12-01 18:43:57 +0000
@@ -2,8 +2,9 @@
 #define CONFIG_H
 
 #cmakedefine PREFIXPATH "@PREFIXPATH@"
-#cmakedefine UNITYDATADIR "@UNITYDATADIR@"
-#cmakedefine UNITYLIBDIR "@UNITYLIBDIR@"
+#cmakedefine UNITY_DATADIR "@UNITY_DATADIR@"
+#cmakedefine UNITY_LIBDIR "@UNITY_LIBDIR@"
+#cmakedefine UNITY_INSTALL_LIBDIR "@UNITY_INSTALL_LIBDIR@"
 #cmakedefine PKGDATADIR "@PKGDATADIR@"
 #cmakedefine LOCALE_DIR "@LOCALE_DIR@"
 #cmakedefine VERSION "@VERSION@"
 
=== modified file 'dash/ResultRendererTile.cpp'
--- dash/ResultRendererTile.cpp	2016-02-09 18:16:51 +0000
+++ dash/ResultRendererTile.cpp	2017-12-01 18:43:57 +0000
@@ -273,7 +273,7 @@
   std::string const& icon_hint = row.icon_hint;
   std::string const& icon_name = !icon_hint.empty() ? icon_hint : DEFAULT_GICON;
 
-  glib::Object<GIcon> icon(g_icon_new_for_string(icon_name.c_str(), NULL));
+  glib::Object<GIcon> icon(g_icon_new_for_string(icon_name.c_str(), nullptr));
   TextureContainer* container = row.renderer<TextureContainer*>();
 
   if (container)
 
=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2014-05-27 07:53:19 +0000
+++ data/CMakeLists.txt	2017-12-01 18:43:57 +0000
@@ -1,1 +1,37 @@
-add_subdirectory(pam)
 \ No newline at end of file
+add_subdirectory(pam)
+
+# GSettings Schema
+SET (UNITY_SCHEMAS "com.canonical.Unity.gschema.xml")
+SET (UNITY_TEST_SCHEMAS "external.gschema.xml")
+
+# Have an option to not install the schema into where GLib is
+option (GSETTINGS_LOCALINSTALL "Install GSettings Schemas locally instead of to the GLib prefix" OFF)
+if (GSETTINGS_LOCALINSTALL)
+    SET (GSETTINGS_DIR "${CMAKE_INSTALL_DATADIR}/glib-2.0/schemas/")
+else (GSETTINGS_LOCALINSTALL)
+    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} glib-2.0 --variable prefix  OUTPUT_VARIABLE _glib_prefix OUTPUT_STRIP_TRAILING_WHITESPACE)
+    SET (GSETTINGS_DIR "${_glib_prefix}/share/glib-2.0/schemas/")
+endif (GSETTINGS_LOCALINSTALL)
+
+# Run the validator and error if it fails
+execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} gio-2.0 --variable glib_compile_schemas  OUTPUT_VARIABLE _glib_comple_schemas OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process (COMMAND ${_glib_comple_schemas} --dry-run --schema-file=${CMAKE_CURRENT_SOURCE_DIR}/${UNITY_SCHEMAS} ERROR_VARIABLE _schemas_invalid OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+if (_schemas_invalid)
+  message (SEND_ERROR "Schema validation error: ${_schemas_invalid}")
+endif (_schemas_invalid)
+
+# Actually install and recomple schemas
+message (STATUS "GSettings schemas will be installed into ${GSETTINGS_DIR}")
+install (FILES ${UNITY_SCHEMAS} DESTINATION ${GSETTINGS_DIR} OPTIONAL)
+install (CODE "message (STATUS \"Compiling GSettings schemas\")")
+install (CODE "execute_process (COMMAND ${_glib_comple_schemas} ${GSETTINGS_DIR})")
+
+# Settings for testing
+configure_file (${CMAKE_SOURCE_DIR}/data/${UNITY_SCHEMAS} ${CMAKE_BINARY_DIR}/settings/${UNITY_SCHEMAS})
+configure_file (${CMAKE_SOURCE_DIR}/tests/data/${UNITY_TEST_SCHEMAS} ${CMAKE_BINARY_DIR}/settings/${UNITY_TEST_SCHEMAS})
+execute_process (COMMAND ${_glib_comple_schemas} ${CMAKE_BINARY_DIR}/settings)
+
+# Upstart
+configure_file(unity7.conf.in ${CMAKE_CURRENT_BINARY_DIR}/unity7.conf)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/unity7.conf DESTINATION ${CMAKE_INSTALL_DATADIR}/upstart/sessions)
 
=== renamed file 'com.canonical.Unity.gschema.xml' => 'data/com.canonical.Unity.gschema.xml'
--- com.canonical.Unity.gschema.xml	2016-06-28 16:23:15 +0000
+++ data/com.canonical.Unity.gschema.xml	2017-12-01 18:43:57 +0000
@@ -100,6 +100,11 @@
         when authenticating.  Only do this if you have account
         configured properly on your system.</description>
     </key>
+    <key type="b" name="lowgfx">
+      <default>false</default>
+      <summary>Enable/Disable Low Graphics Mode</summary>
+      <description>Whether Unity runs in Low Graphics Mode.</description>
+    </key>
   </schema>
   <schema path="/com/canonical/unity/interface/" id="com.canonical.Unity.Interface" gettext-domain="unity">
     <key type="d" name="text-scale-factor">
 
=== renamed file 'unity7.conf.in' => 'data/unity7.conf.in'
--- unity7.conf.in	2016-08-01 08:37:57 +0000
+++ data/unity7.conf.in	2017-12-01 18:43:57 +0000
@@ -5,25 +5,8 @@
 stop on desktop-end
 
 pre-start script
-  # If gnome-session is going to start compiz,
-  # we don't want to be the ones doing it.
-
-  if grep -q compiz /usr/share/gnome-session/sessions/ubuntu.session ; then
-    echo "GNOME Session is starting Compiz"
-    stop ; exit 0
-  fi
-
-  compiz_profile="ubuntu"
-
-  if ! /usr/lib/nux/unity_support_test -p; then
-    compiz_profile="ubuntu-lowgfx"
-  fi
-
-  echo "Using compiz profile '$compiz_profile'"
-  initctl set-env -g COMPIZ_CONFIG_PROFILE="$compiz_profile"
-  export COMPIZ_CONFIG_PROFILE="$compiz_profile"
-
-  ${CMAKE_INSTALL_FULL_LIBDIR}/unity/unity-active-plugins-safety-check
+  @UNITY_LIBDIR@/upstart-prestart-check
+  @UNITY_LIBDIR@/compiz-profile-selector
 end script
 
 respawn
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-09-06 23:17:39 +0000
+++ debian/changelog	2017-12-01 18:43:57 +0000
@@ -1,3 +1,81 @@
+unity (7.4.5+16.04) UNRELEASED; urgency=medium
+
+  [ Marco Trevisan (Treviño) ]
+  * InputMonitor: add an unity class that monitors XInput2 events and
+    converts them to XEvent
+  * EdgeBarrierController: use InputMonitor to get the barrier events
+    instead of relying on its implementation
+  * DecorationsMenuLayout: use input monitor for menu scrubbing (LP:
+    #1614597)
+  * PanelView: use InputMonitor to track menu events
+  * LockScreenPanel: use InputMonitor events instead of mouse polling
+    for menu scrubbing
+  * MenuManager: add support for mouse trackers with triangle algorithm
+    support (LP: #1618405)
+  * PanelView: scale gradient refinement properly
+  * PanelService: don't allow to deactivate menus if they've been opened
+    too shortly
+  * LockScreenController: ignore icon_paths_changed signal in
+    menumanager for Lockscreen
+  * LockScreenController: use InputMonitor to get all the events and
+    hide the Blank Window (LP: #1321075)
+  * LockScreenController: use input monitor to get the events to switch
+    monitor (LP: #1316862)
+  * LauncherOptions: use track_obj to manage option changes (LP:
+    #1622995)
+  * UnityScreen: toggle gestures recognition on lock (LP: #1645507)
+  * GnomeSessionManager: add gcancellable to instance and use it for
+    calls with temporary proxies
+  * BackgroundSettings: use gnome-bg to generate textures with proper
+    scaling (LP: #1666359)
+  * UnityWindow: safely check validity of UnityWindow from scaled one
+    (LP: #1659847)
+  * Panel: ensure the menu-manager tracker is updated to match monitor
+    (LP: #1671432)
+  * compiz-profile-setter: tool to update the current profile and use in
+    systemd and Unity settings (LP: #1668950)
+  * BGHash, UnityScreen: get desktop averageColor from compiz
+  * Launcher: disable or reduce most icon effects on lowgfx (LP:
+    #1700859)
+  * PanelController: ensure we disconnect from signals on destruction
+    (LP: #1504870)
+  * tools: add migration script to set the default values for unity-
+    lowgfx profile
+
+  [ Andrea Azzarone ]
+  * Properly handle the file manager copy dialog in
+    FileManagerLauncherIcon and in StorageLauncherIcon. (LP: #1575452,
+    LP: #1609845)
+  * Correctly position the force quit dialog when scaling is different
+    than 1.0 (LP: #1637991)
+  * GnomeSession: Retrieve the session id using dbus if $XDG_SESSION_ID
+    is not set
+  * Round gtk scaling factor to closest integer. (LP: #1649736)
+  * Keep the screen locked if rebooting with autologin. (LP: #1600389)
+  * Use g_mkdir_with_parents instead of mkdir.
+  * Lockscreen: always draw the background-color in the lockscreen (LP:
+    #1702701)
+  * Refactor the way UserAuthenticator is created and passed around.
+    Handle failures to create new threads and fallback to a "Switch to
+    greeter..." button in case of failure. (LP: #1311316)
+  * Wait until the color buffer is cleared before suspending. (LP:
+    #1532508)
+
+  [ Kai-Heng Feng ]
+  * UnitySettings: If scale-factor is not set, find and set right scale
+    for HiDPI displays.
+
+  [ Eleni Maria Stea ]
+  * shouldn't create blur rectangles when there's no blur, skips the
+    blur rects processing in low gfx.
+  * removes lowgfx option from ccsm, reads the "lowgfx" gsetting (LP:
+    #1668950)
+
+  [ Nick Dedekind ]
+  * Fixed tooltip scaling issues. (LP: #1673950)
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Tue, 04 Jul 2017 18:12:47 +0200
+
 unity (7.4.0+16.04.20160906-0ubuntu1) xenial; urgency=medium
 
   [ Marco Trevisan (Treviño) ]
 
=== modified file 'debian/control'
--- debian/control	2016-08-01 08:37:57 +0000
+++ debian/control	2017-12-01 18:43:57 +0000
@@ -3,9 +3,10 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: cmake,
-               compiz-dev (>= 1:0.9.12.2),
+               compiz-dev (>= 1:0.9.12.3+16.04.20170704),
                debhelper (>= 9.0.0~),
                dbus-test-runner,
+               dbus-x11,
                dh-migrations,
                dh-translations (>= 94),
                dh-python,
 
=== modified file 'debian/rules'
--- debian/rules	2016-02-09 12:21:08 +0000
+++ debian/rules	2017-12-01 18:43:57 +0000
@@ -6,6 +6,7 @@
 DEB_HOST_ARCH := $(shell dpkg-architecture -qDEB_HOST_ARCH)
 DEB_HOST_GNU_TYPE := $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
 gles2_architectures := armel armhf
+disable_tests_archs := powerpc
 
 DEB_VERSION := $(shell dpkg-parsechangelog | egrep '^Version:' | cut -f 2 -d ' ')
 
@@ -53,8 +54,10 @@
 
 override_dh_auto_test:
 ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS)))
+ifneq ($(DEB_HOST_ARCH),$(findstring $(DEB_HOST_ARCH), $(disable_tests_archs)))
 	make -C obj-$(DEB_HOST_GNU_TYPE) check-headless
 endif
+endif
 
 %:
 	dh $@ --with translations,quilt,python2,python3,migrations --parallel
 
=== modified file 'debian/unity.install'
--- debian/unity.install	2016-08-01 08:37:57 +0000
+++ debian/unity.install	2017-12-01 18:43:57 +0000
@@ -2,6 +2,9 @@
 usr/bin
 usr/lib/*/compiz/libunity*.so
 usr/lib/*/unity/unity-active-plugins-safety-check
+usr/lib/*/unity/compiz-config-profile-setter
+usr/lib/*/unity/compiz-profile-selector
+usr/lib/*/unity/*-prestart-check
 usr/share/man/*/unity.1
 usr/share/compiz
 usr/share/locale
 
=== modified file 'debian/unity.migrations'
--- debian/unity.migrations	2016-02-22 20:34:21 +0000
+++ debian/unity.migrations	2017-12-01 18:43:57 +0000
@@ -2,3 +2,4 @@
 tools/migration-scripts/02_unity_setup_text_scale_factor
 tools/migration-scripts/03_unity_first_run_stamp_move
 tools/migration-scripts/04_unity_update_software_center_desktop_file
+tools/migration-scripts/06_unity_set_lowgfx_mode_settings_v1
 
=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2016-08-06 16:24:45 +0000
+++ decorations/DecoratedWindow.cpp	2017-12-01 18:43:57 +0000
@@ -37,7 +37,6 @@
 {
 namespace
 {
-const std::string MENUS_PANEL_NAME = "WindowLIM";
 const int SHADOW_BLUR_MARGIN_FACTOR = 2;
 }
 
@@ -55,7 +54,6 @@
   , deco_elements_(cu::DecorationElement::NONE)
   , last_mwm_decor_(win_->mwmDecor())
   , last_actions_(win_->actions())
-  , panel_id_(MENUS_PANEL_NAME + std::to_string(win_->id()))
   , cv_(Settings::Instance().em())
 {
   active.changed.connect([this] (bool active) {
@@ -932,18 +930,13 @@
     sliding_layout->mouse_owner = grab_edge_->mouse_owner();
 }
 
-inline std::string const& Window::Impl::GetMenusPanelID() const
-{
-  return panel_id_;
-}
-
 void Window::Impl::UnsetAppMenu()
 {
   if (!menus_)
     return;
 
   auto const& indicators = manager_->impl_->menu_manager_->Indicators();
-  indicators->SyncGeometries(GetMenusPanelID(), indicator::EntryLocationMap());
+  indicators->SyncGeometries(menus_->MenubarId(), indicator::EntryLocationMap());
   sliding_layout_->SetInputItem(nullptr);
   grab_mouse_changed_->disconnect();
 }
@@ -956,7 +949,7 @@
   auto const& indicators = manager_->impl_->menu_manager_->Indicators();
   indicator::EntryLocationMap map;
   menus_->ChildrenGeometries(map);
-  indicators->SyncGeometries(GetMenusPanelID(), map);
+  indicators->SyncGeometries(menus_->MenubarId(), map);
 }
 
 bool Window::Impl::ActivateMenu(std::string const& entry_id)
 
=== modified file 'decorations/DecorationsForceQuitDialog.cpp'
--- decorations/DecorationsForceQuitDialog.cpp	2016-08-06 16:24:55 +0000
+++ decorations/DecorationsForceQuitDialog.cpp	2017-12-01 18:43:57 +0000
@@ -478,9 +478,11 @@
 
   void UpdateDialogPosition()
   {
+    gint scale = gtk_widget_get_scale_factor(dialog_);
+    scale = std::max<gint>(1, scale);
     auto const& win_geo = win_->inputRect();
-    nux::Size walloc(gtk_widget_get_allocated_width(dialog_), gtk_widget_get_allocated_height(dialog_));
-    gtk_window_move(GTK_WINDOW(dialog_), win_geo.centerX() - walloc.width/2, win_geo.centerY() - walloc.height/2);
+    nux::Size walloc(gtk_widget_get_allocated_width(dialog_) * scale, gtk_widget_get_allocated_height(dialog_) * scale);
+    gtk_window_move(GTK_WINDOW(dialog_), (win_geo.centerX() - walloc.width/2) / scale, (win_geo.centerY() - walloc.height/2) / scale);
   }
 
   ForceQuitDialog* parent_;
 
=== modified file 'decorations/DecorationsMenuLayout.cpp'
--- decorations/DecorationsMenuLayout.cpp	2015-02-03 10:04:17 +0000
+++ decorations/DecorationsMenuLayout.cpp	2017-12-01 18:43:57 +0000
@@ -25,6 +25,10 @@
 {
 namespace decoration
 {
+namespace
+{
+const std::string MENUS_PANEL_NAME = "WindowLIM";
+}
 
 using namespace indicator;
 
@@ -33,8 +37,8 @@
   , show_now(false)
   , menu_manager_(menu)
   , win_(win)
-  , last_pointer_(-1, -1)
   , dropdown_(std::make_shared<MenuDropdown>(menu_manager_->Indicators(), win))
+  , menubar_id_(MENUS_PANEL_NAME + std::to_string(win_->id()))
 {
   visible = false;
 }
@@ -91,6 +95,11 @@
     Relayout();
 }
 
+std::string const& MenuLayout::MenubarId() const
+{
+  return menubar_id_;
+}
+
 bool MenuLayout::ActivateMenu(std::string const& entry_id)
 {
   MenuEntry::Ptr target;
@@ -117,16 +126,29 @@
   if (!activated)
     activated = dropdown_->ActivateChild(target);
 
-  if (activated)
-  {
-    // Since this generally happens on keyboard activation we need to avoid that
-    // the mouse position would interfere with this
-    last_pointer_.set(pointerX, pointerY);
-  }
-
   return activated;
 }
 
+bool MenuLayout::ActivateMenu(CompPoint const& pos)
+{
+  if (!Geometry().contains(pos))
+    return false;
+
+  for (auto const& item : items_)
+  {
+    if (!item->visible() || !item->sensitive())
+      continue;
+
+    if (item->Geometry().contains(pos))
+    {
+      std::static_pointer_cast<MenuEntry>(item)->ShowMenu(1);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 void MenuLayout::OnEntryMouseOwnershipChanged(bool owner)
 {
   mouse_owner = owner;
@@ -154,39 +176,15 @@
 {
   active = actived;
 
-  if (active && !pointer_tracker_ && items_.size() > 1)
+  if (active && items_.size() > 1)
   {
-    pointer_tracker_.reset(new glib::Timeout(16));
-    pointer_tracker_->Run([this] {
-      Window win;
-      int i, x, y;
-      unsigned int ui;
-
-      XQueryPointer(screen->dpy(), screen->root(), &win, &win, &x, &y, &i, &i, &ui);
-
-      if (last_pointer_.x() != x || last_pointer_.y() != y)
-      {
-        last_pointer_.set(x, y);
-
-        for (auto const& item : items_)
-        {
-          if (!item->visible() || !item->sensitive())
-            continue;
-
-          if (item->Geometry().contains(last_pointer_))
-          {
-            std::static_pointer_cast<MenuEntry>(item)->ShowMenu(1);
-            break;
-          }
-        }
-      }
-
-      return true;
-    });
+    menu_manager_->RegisterTracker(menubar_id_, (sigc::track_obj([this] (int x, int y, double speed) {
+      ActivateMenu(CompPoint(x, y));
+    }, *this)));
   }
   else if (!active)
   {
-    pointer_tracker_.reset();
+    menu_manager_->UnregisterTracker(menubar_id_);
   }
 }
 
 
=== modified file 'decorations/DecorationsMenuLayout.h'
--- decorations/DecorationsMenuLayout.h	2014-02-13 03:01:30 +0000
+++ decorations/DecorationsMenuLayout.h	2017-12-01 18:43:57 +0000
@@ -42,7 +42,9 @@
 
   void Setup();
   bool ActivateMenu(std::string const& entry_id);
+  bool ActivateMenu(CompPoint const&);
   void ChildrenGeometries(indicator::EntryLocationMap&) const;
+  std::string const& MenubarId() const;
 
 protected:
   void DoRelayout() override;
@@ -55,10 +57,9 @@
 
   menu::Manager::Ptr menu_manager_;
   CompWindow* win_;
-  CompPoint last_pointer_;
-  glib::Source::UniquePtr pointer_tracker_;
   glib::Source::UniquePtr show_now_timeout_;
   std::shared_ptr<MenuDropdown> dropdown_;
+  std::string menubar_id_;
 };
 
 } // decoration namespace
 
=== modified file 'decorations/DecorationsPriv.h'
--- decorations/DecorationsPriv.h	2016-08-06 16:24:45 +0000
+++ decorations/DecorationsPriv.h	2017-12-01 18:43:57 +0000
@@ -162,7 +162,6 @@
   connection::Wrapper dpi_changed_;
   connection::Wrapper grab_mouse_changed_;
   std::string last_title_;
-  std::string panel_id_;
   std::vector<cu::SimpleTextureQuad> bg_textures_;
   cu::PixmapTexture::Ptr shaped_shadow_pixmap_;
   std::shared_ptr<ForceQuitDialog> force_quit_;
 
=== modified file 'decorations/DecorationsWindowButton.cpp'
--- decorations/DecorationsWindowButton.cpp	2016-08-06 16:24:45 +0000
+++ decorations/DecorationsWindowButton.cpp	2017-12-01 18:43:57 +0000
@@ -45,7 +45,8 @@
 
 void WindowButton::UpdateTexture()
 {
-  SetTexture(DataPool::Get()->ButtonTexture(scale(), type(), GetCurrentState()));
+  if (auto tex = DataPool::Get()->ButtonTexture(scale(), type(), GetCurrentState()))
+    SetTexture(tex);
 }
 
 WidgetState WindowButton::GetCurrentState() const
 
=== modified file 'launcher/EdgeBarrierController.cpp'
--- launcher/EdgeBarrierController.cpp	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierController.cpp	2017-12-01 18:43:57 +0000
@@ -25,6 +25,7 @@
 #include <NuxCore/Logger.h>
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/UScreen.h"
+#include "unity-shared/InputMonitor.h"
 #include "UnityCore/GLibSource.h"
 
 namespace unity
@@ -36,50 +37,10 @@
 {
   int const Y_BREAK_BUFFER = 20;
   int const X_BREAK_BUFFER = 20;
-  int const MAJOR = 2;
-  int const MINOR = 3;
-}
-
-DECLARE_LOGGER(logger, "unity.edge_barrier_controller");
-
-int GetXI2OpCode()
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-
-  int opcode, event_base, error_base;
-  if (!XQueryExtension(dpy, "XFIXES",
-                       &opcode,
-                       &event_base,
-                       &error_base))
-  {
-    LOG_ERROR(logger) << "Missing XFixes";
-    return -1;
-  }
-
-  if (!XQueryExtension (dpy, "XInputExtension",
-                        &opcode,
-                        &event_base,
-                        &error_base))
-  {
-    LOG_ERROR(logger) << "Missing XInput";
-    return -1;
-  }
-
-  int maj = MAJOR;
-  int min = MINOR;
-
-  if (XIQueryVersion(dpy, &maj, &min) == BadRequest)
-  {
-    LOG_ERROR(logger) << "Need XInput version 2.3";
-    return -1;
-  }
-
-  return opcode;
 }
 
 EdgeBarrierController::Impl::Impl(EdgeBarrierController *parent)
-  : xi2_opcode_(-1)
-  , edge_overcome_pressure_(0)
+  : edge_overcome_pressure_(0)
   , parent_(parent)
 {
   UScreen *uscreen = UScreen::GetDefault();
@@ -119,8 +80,6 @@
     options->option_changed.connect(sigc::mem_fun(this, &EdgeBarrierController::Impl::OnOptionsChanged));
     SetupBarriers(UScreen::GetDefault()->GetMonitors());
   });
-
-  xi2_opcode_ = GetXI2OpCode();
 }
 
 EdgeBarrierController::Impl::~Impl()
@@ -202,36 +161,30 @@
   }
 }
 
-void SetupXI2Events()
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-
-  unsigned char mask_bits[XIMaskLen (XI_LASTEVENT)] = { 0 };
-  XIEventMask mask = { XIAllMasterDevices, sizeof (mask_bits), mask_bits };
-
-  XISetMask(mask.mask, XI_BarrierHit);
-  XISetMask(mask.mask, XI_BarrierLeave);
-  XISelectEvents (dpy, DefaultRootWindow(dpy), &mask, 1);
-}
-
 void EdgeBarrierController::Impl::SetupBarriers(std::vector<nux::Geometry> const& layout)
 {
   if (parent_->force_disable())
     return;
 
+  size_t monitors_size = layout.size();
+  auto launcher_position = Settings::Instance().launcher_position();
   bool edge_resist = parent_->sticky_edges();
-  auto launcher_position = Settings::Instance().launcher_position();
-
-  for (unsigned i = 0; i < layout.size(); i++)
+  bool needs_barrier = edge_resist && monitors_size > 1;
+  bool needs_vertical_barrier = needs_barrier;
+
+  if (parent_->options()->hide_mode() != launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER)
+    needs_vertical_barrier = true;
+
+  for (unsigned i = 0; i < layout.size(); ++i)
   {
-    auto vertical_barrier = vertical_barriers_[i];
-    auto horizontal_barrier = horizontal_barriers_[i];
-    auto monitor = layout[i];
+    auto const& vertical_barrier = vertical_barriers_[i];
+    auto const& horizontal_barrier = horizontal_barriers_[i];
+    auto const& monitor = layout[i];
 
     vertical_barrier->DestroyBarrier();
     horizontal_barrier->DestroyBarrier();
 
-    if (edge_resist)
+    if (needs_barrier)
     {
       horizontal_barrier->x1 = monitor.x;
       horizontal_barrier->x2 = monitor.x + monitor.width;
@@ -246,7 +199,7 @@
       horizontal_barrier->ConstructBarrier();
     }
 
-    if (!edge_resist && parent_->options()->hide_mode() == launcher::LauncherHideMode::LAUNCHER_HIDE_NEVER)
+    if (!needs_vertical_barrier)
       continue;
 
     if (launcher_position == LauncherPosition::LEFT)
@@ -273,8 +226,10 @@
     vertical_barrier->ConstructBarrier();
   }
 
-  SetupXI2Events();
-  AddEventFilter();
+  if (needs_barrier || needs_vertical_barrier)
+    input::Monitor::Get().RegisterClient(input::Events::BARRIER, sigc::mem_fun(this, &Impl::HandleEvent));
+  else
+    input::Monitor::Get().UnregisterClient(sigc::mem_fun(this, &Impl::HandleEvent));
 
   float decay_responsiveness_mult = ((parent_->options()->edge_responsiveness() - 1) * .3f) + 1;
   decaymulator_.rate_of_decay = parent_->options()->edge_decay_rate() * decay_responsiveness_mult;
@@ -283,65 +238,25 @@
   edge_overcome_pressure_ = parent_->options()->edge_overcome_pressure() * overcome_responsiveness_mult;
 }
 
-void EdgeBarrierController::Impl::AddEventFilter()
-{
-  // Remove an old one, if it exists
-  nux::GetGraphicsDisplay()->RemoveEventFilter(this);
-
-  nux::GraphicsDisplay::EventFilterArg event_filter;
-  event_filter.filter = &HandleEventCB;
-  event_filter.data = this;
-
-  nux::GetGraphicsDisplay()->AddEventFilter(event_filter);
-}
-
-bool EdgeBarrierController::Impl::HandleEvent(XEvent xevent)
-{
-  Display *dpy = nux::GetGraphicsDisplay()->GetX11Display();
-  XGenericEventCookie *cookie = &xevent.xcookie;
-  bool ret = false;
-
-  switch (cookie->evtype)
-  {
-    case (XI_BarrierHit):
-    {
-      if (XGetEventData(dpy, cookie))
-      {
-        XIBarrierEvent* barrier_event = (XIBarrierEvent*)cookie->data;
-        PointerBarrierWrapper::Ptr wrapper = FindBarrierEventOwner(barrier_event);
-
-        if (wrapper)
-          ret = wrapper->HandleBarrierEvent(barrier_event);
-      }
-
-      XFreeEventData(dpy, cookie);
-      break;
-    }
-    default:
-      break;
-  }
-
-  return ret;
-}
-
-bool EdgeBarrierController::Impl::HandleEventCB(XEvent xevent, void* data)
-{
-  auto edge_barrier_controller = static_cast<EdgeBarrierController::Impl*>(data);
-  int const xi2_opcode = edge_barrier_controller->xi2_opcode_;
-
-  if (xevent.type != GenericEvent || xevent.xcookie.extension != xi2_opcode)
-    return false;
-
-  return edge_barrier_controller->HandleEvent(xevent);
+void EdgeBarrierController::Impl::HandleEvent(XEvent const& xevent)
+{
+  if (xevent.xcookie.evtype != XI_BarrierHit)
+    return;
+
+  auto* barrier_event = reinterpret_cast<XIBarrierEvent*>(xevent.xcookie.data);
+  PointerBarrierWrapper::Ptr const& wrapper = FindBarrierEventOwner(barrier_event);
+
+  if (wrapper)
+    wrapper->HandleBarrierEvent(barrier_event);
 }
 
 PointerBarrierWrapper::Ptr EdgeBarrierController::Impl::FindBarrierEventOwner(XIBarrierEvent* barrier_event)
 {
-  for (auto barrier : vertical_barriers_)
+  for (auto const& barrier : vertical_barriers_)
     if (barrier->OwnsBarrierEvent(barrier_event->barrier))
       return barrier;
 
-  for (auto barrier : horizontal_barriers_)
+  for (auto const& barrier : horizontal_barriers_)
     if (barrier->OwnsBarrierEvent(barrier_event->barrier))
       return barrier;
 
 
=== modified file 'launcher/EdgeBarrierControllerPrivate.h'
--- launcher/EdgeBarrierControllerPrivate.h	2015-12-23 09:29:24 +0000
+++ launcher/EdgeBarrierControllerPrivate.h	2017-12-01 18:43:57 +0000
@@ -53,12 +53,8 @@
   bool EventIsInsideYBreakZone(BarrierEvent::Ptr const& event);
   bool EventIsInsideXBreakZone(BarrierEvent::Ptr const& event);
 
-  void AddEventFilter();
-
   PointerBarrierWrapper::Ptr FindBarrierEventOwner(XIBarrierEvent* barrier_event);
-
-  static bool HandleEventCB(XEvent event, void* data);
-  bool HandleEvent(XEvent event);
+  void HandleEvent(XEvent const&);
 
   std::vector<PointerBarrierWrapper::Ptr> vertical_barriers_;
   std::vector<PointerBarrierWrapper::Ptr> horizontal_barriers_;
@@ -68,7 +64,6 @@
 
   Decaymulator decaymulator_;
   glib::Source::UniquePtr release_timeout_;
-  int xi2_opcode_;
   float edge_overcome_pressure_;
   EdgeBarrierController* parent_;
 };
 
=== modified file 'launcher/FileManagerLauncherIcon.cpp'
--- launcher/FileManagerLauncherIcon.cpp	2016-07-14 10:04:31 +0000
+++ launcher/FileManagerLauncherIcon.cpp	2017-12-01 18:43:57 +0000
@@ -49,6 +49,11 @@
   SetQuirk(Quirk::VISIBLE, false);
   SkipQuirkAnimation(Quirk::VISIBLE);
 
+  signals_conn_.Add(app_->window_opened.connect([this](ApplicationWindowPtr const& win) {
+    signals_conn_.Add(win->monitor.changed.connect([this] (int) { UpdateStorageWindows(); }));
+    UpdateStorageWindows();
+  }));
+
   signals_conn_.Add(app_->desktop_file.changed.connect([this](std::string const& desktop_file) {
     LOG_DEBUG(logger) << tooltip_text() << " desktop_file now " << desktop_file;
     UpdateDesktopFile();
@@ -134,5 +139,30 @@
   return StorageLauncherIcon::OnShouldHighlightOnDrag(dnd_data);
 }
 
+bool FileManagerLauncherIcon::IsUserVisible() const
+{
+  return ApplicationLauncherIcon::IsUserVisible();
+}
+
+WindowList FileManagerLauncherIcon::WindowsOnViewport()
+{
+  WindowFilterMask filter = 0;
+  filter |= WindowFilter::MAPPED;
+  filter |= WindowFilter::ON_CURRENT_DESKTOP;
+  filter |= WindowFilter::ON_ALL_MONITORS;
+
+  return WindowedLauncherIcon::GetWindows(filter);
+}
+
+WindowList FileManagerLauncherIcon::WindowsForMonitor(int monitor)
+{
+  WindowFilterMask filter = 0;
+  filter |= WindowFilter::MAPPED;
+  filter |= WindowFilter::ON_CURRENT_DESKTOP;
+
+  return WindowedLauncherIcon::GetWindows(filter, monitor);
+}
+
+
 } // namespace launcher
 } // namespace unity
 
=== modified file 'launcher/FileManagerLauncherIcon.h'
--- launcher/FileManagerLauncherIcon.h	2015-12-09 12:02:48 +0000
+++ launcher/FileManagerLauncherIcon.h	2017-12-01 18:43:57 +0000
@@ -32,8 +32,16 @@
 class FileManagerLauncherIcon : public ApplicationLauncherIcon, public StorageLauncherIcon
 {
 public:
+  typedef nux::ObjectPtr<FileManagerLauncherIcon> Ptr;
+
   FileManagerLauncherIcon(ApplicationPtr const&, DeviceLauncherSection::Ptr const&, FileManager::Ptr const& = nullptr);
 
+  bool IsUserVisible() const override;
+
+protected:
+  WindowList WindowsOnViewport() override;
+  WindowList WindowsForMonitor(int monitor) override;
+
 private:
   WindowList GetManagedWindows() const override;
   WindowList GetStorageWindows() const override;
 
=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2016-07-05 10:22:42 +0000
+++ launcher/Launcher.cpp	2017-12-01 18:43:57 +0000
@@ -138,13 +138,6 @@
   , drag_action_(nux::DNDACTION_NONE)
   , bg_effect_helper_(this)
   , launcher_position_(unity::Settings::Instance().launcher_position())
-  , auto_hide_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION_SHORT)
-  , hover_animation_(Settings::Instance().low_gfx ? ANIM_DURATION_SHORT_SHORT : ANIM_DURATION)
-  , drag_over_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION_LONG)
-  , drag_out_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION_SHORT)
-  , drag_icon_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION_SHORT)
-  , dnd_hide_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION * 3)
-  , dash_showing_animation_(Settings::Instance().low_gfx ? 0 : ANIM_DURATION_DASH_SHOWING)
   , cv_(Settings::Instance().em(monitor))
 {
   icon_renderer_->monitor = monitor();
@@ -199,17 +192,9 @@
   });
 
   Settings::Instance().dpi_changed.connect(sigc::mem_fun(this, &Launcher::OnDPIChanged));
-  Settings::Instance().low_gfx.changed.connect(sigc::track_obj([this] (bool low_gfx) {
-    auto_hide_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
-    hover_animation_.SetDuration(low_gfx ? ANIM_DURATION_SHORT_SHORT : ANIM_DURATION);
-    drag_over_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_LONG);
-    drag_out_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
-    drag_icon_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
-    dnd_hide_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION * 3);
-    dash_showing_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_DASH_SHOWING);
-    QueueDraw();
-  }, *this));
+  Settings::Instance().low_gfx.changed.connect(sigc::hide(sigc::mem_fun(this, &Launcher::UpdateAnimations)));
 
+  UpdateAnimations();
   auto_hide_animation_.updated.connect(redraw_cb);
   hover_animation_.updated.connect(redraw_cb);
   drag_over_animation_.updated.connect(redraw_cb);
@@ -1356,13 +1341,29 @@
   SetLauncherMinimizeWindow(options->minimize_window_on_click);
   OnMonitorChanged(monitor);
 
+  UpdateAnimations();
+  ConfigureBarrier();
+  QueueDraw();
+}
+
+void Launcher::UpdateAnimations()
+{
+  bool low_gfx = Settings::Instance().low_gfx();
+
+  auto_hide_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
+  hover_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION);
+  drag_over_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_LONG);
+  drag_out_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
+  drag_icon_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_SHORT);
+  dnd_hide_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION * 3);
+  dash_showing_animation_.SetDuration(low_gfx ? 0 : ANIM_DURATION_DASH_SHOWING);
+
   if (model_)
   {
     for (auto const& icon : *model_)
       SetupIconAnimations(icon);
   }
 
-  ConfigureBarrier();
   QueueDraw();
 }
 
@@ -1739,23 +1740,26 @@
 
 void Launcher::SetupIconAnimations(AbstractLauncherIcon::Ptr const& icon)
 {
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::VISIBLE, ANIM_DURATION_SHORT, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::RUNNING, ANIM_DURATION_SHORT, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::ACTIVE, ANIM_DURATION_SHORT, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::STARTING, (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2), monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PULSE_ONCE, (ANIM_DURATION_LONG * PULSE_BLINK_LAMBDA * 2), monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PRESENTED, ANIM_DURATION, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::UNFOLDED, ANIM_DURATION, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::SHIMMER, ANIM_DURATION_LONG, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::CENTER_SAVED, ANIM_DURATION, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PROGRESS, ANIM_DURATION, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::DESAT, ANIM_DURATION_SHORT_SHORT, monitor());
-  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::GLOW, ANIM_DURATION_SHORT, monitor());
+  bool display = monitor();
+  bool low_gfx = Settings::Instance().low_gfx();
+
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::VISIBLE, low_gfx ? 0 : ANIM_DURATION_SHORT, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::RUNNING, low_gfx ? 0 : ANIM_DURATION_SHORT, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::ACTIVE, low_gfx ? 0 : ANIM_DURATION_SHORT, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::STARTING, (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2), display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PULSE_ONCE, (ANIM_DURATION_LONG * PULSE_BLINK_LAMBDA * 2), display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PRESENTED, low_gfx ? 0 : ANIM_DURATION, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::UNFOLDED, low_gfx ? 0 : ANIM_DURATION, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::SHIMMER, low_gfx ? ANIM_DURATION_SHORT_SHORT : ANIM_DURATION_LONG, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::CENTER_SAVED, low_gfx ? ANIM_DURATION_SHORT_SHORT : ANIM_DURATION, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::PROGRESS, low_gfx ? ANIM_DURATION_SHORT_SHORT : ANIM_DURATION, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::DESAT, low_gfx ? 0 : ANIM_DURATION_SHORT_SHORT, display);
+  icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::GLOW, low_gfx ? 0 : ANIM_DURATION_SHORT, display);
 
   if (options()->urgent_animation() == URGENT_ANIMATION_WIGGLE)
-    icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::URGENT, (ANIM_DURATION_SHORT * WIGGLE_CYCLES), monitor());
+    icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::URGENT, (ANIM_DURATION_SHORT * WIGGLE_CYCLES), display);
   else
-    icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::URGENT, (ANIM_DURATION_LONG * URGENT_BLINKS * 2), monitor());
+    icon->SetQuirkDuration(AbstractLauncherIcon::Quirk::URGENT, (ANIM_DURATION_LONG * URGENT_BLINKS * 2), display);
 }
 
 void Launcher::SetModel(LauncherModel::Ptr model)
 
=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2016-03-30 18:18:07 +0000
+++ launcher/Launcher.h	2017-12-01 18:43:57 +0000
@@ -195,6 +195,7 @@
   void OnOptionsChanged(Options::Ptr options);
   void OnOptionChanged();
   void UpdateOptions(Options::Ptr options);
+  void UpdateAnimations();
 
 #ifdef NUX_GESTURES_SUPPORT
   void OnDragStart(const nux::GestureEvent &event);
 
=== modified file 'launcher/LauncherOptions.cpp'
--- launcher/LauncherOptions.cpp	2014-03-17 20:58:25 +0000
+++ launcher/LauncherOptions.cpp	2017-12-01 18:43:57 +0000
@@ -49,31 +49,31 @@
   , scroll_inactive_icons(false)
   , minimize_window_on_click(false)
 {
-  auto changed_lambda = [this] {
+  auto changed_cb = sigc::track_obj(sigc::hide([this] {
     changed_idle_.reset(new glib::Idle(glib::Source::Priority::HIGH));
     changed_idle_->Run([this] { option_changed.emit(); return false; });
-  };
+  }), *this);
 
-  auto_hide_animation.changed.connect(sigc::hide(changed_lambda));
-  background_alpha.changed.connect(sigc::hide(changed_lambda));
-  background_color.changed.connect(sigc::hide(changed_lambda));
-  backlight_mode.changed.connect(sigc::hide(changed_lambda));
-  edge_decay_rate.changed.connect(sigc::hide(changed_lambda));
-  edge_overcome_pressure.changed.connect(sigc::hide(changed_lambda));
-  edge_responsiveness.changed.connect(sigc::hide(changed_lambda));
-  edge_reveal_pressure.changed.connect(sigc::hide(changed_lambda));
-  edge_stop_velocity.changed.connect(sigc::hide(changed_lambda));
-  edge_passed_disabled_ms.changed.connect(sigc::hide(changed_lambda));
-  hide_mode.changed.connect(sigc::hide(changed_lambda));
-  icon_size.changed.connect(sigc::hide(changed_lambda));
-  launch_animation.changed.connect(sigc::hide(changed_lambda));
-  reveal_trigger.changed.connect(sigc::hide(changed_lambda));
-  tile_size.changed.connect(sigc::hide(changed_lambda));
-  super_tap_duration.changed.connect(sigc::hide(changed_lambda));
-  urgent_animation.changed.connect(sigc::hide(changed_lambda));
-  edge_resist.changed.connect(sigc::hide(changed_lambda));
-  scroll_inactive_icons.changed.connect(sigc::hide(changed_lambda));
-  minimize_window_on_click.changed.connect(sigc::hide(changed_lambda));
+  auto_hide_animation.changed.connect(changed_cb);
+  background_alpha.changed.connect(changed_cb);
+  background_color.changed.connect(changed_cb);
+  backlight_mode.changed.connect(changed_cb);
+  edge_decay_rate.changed.connect(changed_cb);
+  edge_overcome_pressure.changed.connect(changed_cb);
+  edge_responsiveness.changed.connect(changed_cb);
+  edge_reveal_pressure.changed.connect(changed_cb);
+  edge_stop_velocity.changed.connect(changed_cb);
+  edge_passed_disabled_ms.changed.connect(changed_cb);
+  hide_mode.changed.connect(changed_cb);
+  icon_size.changed.connect(changed_cb);
+  launch_animation.changed.connect(changed_cb);
+  reveal_trigger.changed.connect(changed_cb);
+  tile_size.changed.connect(changed_cb);
+  super_tap_duration.changed.connect(changed_cb);
+  urgent_animation.changed.connect(changed_cb);
+  edge_resist.changed.connect(changed_cb);
+  scroll_inactive_icons.changed.connect(changed_cb);
+  minimize_window_on_click.changed.connect(changed_cb);
 }
 
 }
 
=== modified file 'launcher/StorageLauncherIcon.cpp'
--- launcher/StorageLauncherIcon.cpp	2015-12-08 14:31:30 +0000
+++ launcher/StorageLauncherIcon.cpp	2017-12-01 18:43:57 +0000
@@ -36,7 +36,7 @@
   bool active = false;
   bool urgent = false;
   bool check_visibility = (GetIconType() == IconType::APPLICATION);
-  bool visible = IsSticky();
+  bool visible = false;
 
   managed_windows_ = GetStorageWindows();
   windows_connections_.Clear();
@@ -54,13 +54,8 @@
     if (!urgent && win->urgent())
       urgent = true;
 
-    if (check_visibility)
-    {
-      windows_connections_.Add(win->visible.changed.connect([this] (bool) { OnWindowStateChanged(); }));
-
-      if (!visible && win->visible())
-        visible = true;
-    }
+    if (check_visibility && !visible)
+      visible = true;
   }
 
   SetQuirk(Quirk::RUNNING, !managed_windows_.empty());
@@ -68,7 +63,7 @@
   SetQuirk(Quirk::URGENT, urgent);
 
   if (check_visibility)
-    SetQuirk(Quirk::VISIBLE, visible);
+    SetQuirk(Quirk::VISIBLE, visible || IsSticky());
 
   EnsureWindowsLocation();
 }
@@ -83,7 +78,7 @@
   bool active = false;
   bool urgent = false;
   bool check_visibility = (GetIconType() == IconType::APPLICATION);
-  bool visible = IsSticky();
+  bool visible = false;
 
   for (auto const& win : managed_windows_)
   {
@@ -93,7 +88,7 @@
     if (!urgent && win->urgent())
       urgent = true;
 
-    if (check_visibility && !visible && win->visible())
+    if (check_visibility && !visible)
       visible = true;
   }
 
@@ -101,7 +96,7 @@
   SetQuirk(Quirk::URGENT, urgent);
 
   if (check_visibility)
-    SetQuirk(Quirk::VISIBLE, visible);
+    SetQuirk(Quirk::VISIBLE, visible || IsSticky());
 }
 
 bool StorageLauncherIcon::OnShouldHighlightOnDrag(DndData const& dnd_data)
 
=== modified file 'launcher/Tooltip.cpp'
--- launcher/Tooltip.cpp	2016-01-29 03:45:34 +0000
+++ launcher/Tooltip.cpp	2017-12-01 18:43:57 +0000
@@ -124,13 +124,13 @@
   {
     int size = 0;
     int max = GetBaseWidth() - ROTATED_ANCHOR_WIDTH.CP(cv_) - 2 * CORNER_RADIUS.CP(cv_) - 2 * _padding.CP(cv_);
-    if (_left_size.CP(cv_) > max)
+    if (_left_size > max)
     {
       size = max;
     }
-    else if (_left_size.CP(cv_) > 0)
+    else if (_left_size > 0)
     {
-      size = _left_size.CP(cv_);
+      size = _left_size;
     }
     x = _anchorX - (ROTATED_ANCHOR_WIDTH.CP(cv_) / 2) - size - CORNER_RADIUS.CP(cv_) - _padding.CP(cv_);
   }
@@ -222,7 +222,7 @@
   if (Settings::Instance().launcher_position() == LauncherPosition::LEFT)
     _bottom_space->SetMinMaxSize(1, space_height + 1);
   else
-    _bottom_space->SetMinMaxSize(1, space_height + ROTATED_ANCHOR_HEIGHT + 1);
+    _bottom_space->SetMinMaxSize(1, space_height + ROTATED_ANCHOR_HEIGHT.CP(cv_) + 1);
 
   CairoBaseWindow::PreLayoutManagement();
 }
@@ -653,7 +653,7 @@
     height / dpi_scale,
     anchor_width,
     anchor_height,
-    _left_size,
+    _left_size / dpi_scale,
     CORNER_RADIUS,
     blur_coef,
     shadow_color,
@@ -669,7 +669,7 @@
     CORNER_RADIUS,         // radius,
     anchor_width,          // anchor_width,
     anchor_height,         // anchor_height,
-    _left_size,            // left_size,
+    _left_size / dpi_scale,    // left_size,
     true,                  // negative,
     false,                 // outline,
     1.0,                   // line_width,
 
=== modified file 'launcher/Tooltip.h'
--- launcher/Tooltip.h	2015-12-17 01:08:54 +0000
+++ launcher/Tooltip.h	2017-12-01 18:43:57 +0000
@@ -78,7 +78,7 @@
 
   int _anchorX;
   int _anchorY;
-  RawPixel _left_size; // size of the segment from point 10 to 11, used when launcher at bottom.
+  int _left_size; // size of the segment from point 10 to 11, used when launcher at bottom.
   RawPixel _padding;
 
   nux::HLayout* _hlayout;
@@ -94,4 +94,3 @@
 }
 
 #endif // TOOLTIP_H
-
 
=== modified file 'lockscreen/BackgroundSettings.cpp'
--- lockscreen/BackgroundSettings.cpp	2014-07-29 12:05:47 +0000
+++ lockscreen/BackgroundSettings.cpp	2017-12-01 18:43:57 +0000
@@ -53,24 +53,33 @@
   auto& settings = Settings::Instance();
 
   nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, geo.width, geo.height);
-  cairo_surface_set_device_scale(cairo_graphics.GetSurface(), scale, scale);
   cairo_t* c = cairo_graphics.GetInternalContext();
 
+  glib::Object<GnomeBG> gnome_bg;
   double s_width = geo.width / scale;
   double s_height = geo.height / scale;
   cairo_surface_t* bg_surface = nullptr;
 
   if (settings.use_user_background())
   {
-    bg_surface = gnome_bg_create_surface(gnome_bg_, gdk_get_default_root_window(), s_width, s_height, FALSE);
+    gnome_bg = gnome_bg_;
   }
   else if (!settings.background().empty())
   {
-    glib::Object<GdkPixbuf> pixbuf(gdk_pixbuf_new_from_file_at_scale(settings.background().c_str(), s_width, s_height, FALSE, NULL));
-
-    if (pixbuf)
-      bg_surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, 0, NULL);
-  }
+    gnome_bg = gnome_bg_new();
+    gnome_bg_set_filename(gnome_bg, settings.background().c_str());
+    gnome_bg_set_placement(gnome_bg, G_DESKTOP_BACKGROUND_STYLE_ZOOM);
+  }
+
+  if (gnome_bg)
+  {
+    auto *root_window = gdk_get_default_root_window();
+    bg_surface = gnome_bg_create_surface(gnome_bg, root_window, geo.width, geo.height, FALSE);
+  }
+
+  auto const& bg_color = settings.background_color();
+  cairo_set_source_rgb(c, bg_color.red, bg_color.green, bg_color.blue);
+  cairo_paint(c);
 
   if (bg_surface)
   {
@@ -78,12 +87,8 @@
     cairo_paint(c);
     cairo_surface_destroy(bg_surface);
   }
-  else
-  {
-    auto const& bg_color = settings.background_color();
-    cairo_set_source_rgb(c, bg_color.red, bg_color.green, bg_color.blue);
-    cairo_paint(c);
-  }
+
+  cairo_surface_set_device_scale(cairo_graphics.GetSurface(), scale, scale);
 
   if (!settings.logo().empty())
   {
 
=== modified file 'lockscreen/KylinLockScreenShield.cpp'
--- lockscreen/KylinLockScreenShield.cpp	2015-12-07 03:09:28 +0000
+++ lockscreen/KylinLockScreenShield.cpp	2017-12-01 18:43:57 +0000
@@ -37,7 +37,7 @@
                Accelerators::Ptr const& accelerators,
                nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                int monitor_num, bool is_primary)
-  : BaseShield(session_manager, nullptr, accelerators, prompt_view, monitor_num, is_primary)
+  : BaseShield(session_manager, accelerators, prompt_view, monitor_num, is_primary)
 {
   is_primary ? ShowPrimaryView() : ShowSecondaryView();
   EnableInputWindow(true);
@@ -77,23 +77,5 @@
   main_layout->AddSpace(0, 10);
 }
 
-nux::Area* KylinShield::FindKeyFocusArea(unsigned etype, unsigned long keysym, unsigned long modifiers)
-{
-  if (primary)
-  {
-    grab_key.emit(modifiers, keysym);
-
-    if (prompt_view_)
-    {
-      auto* focus_view = prompt_view_->focus_view();
-
-      if (focus_view && focus_view->GetInputEventSensitivity())
-        return focus_view;
-    }
-  }
-
-  return nullptr;
-}
-
 }
 }
 
=== modified file 'lockscreen/KylinLockScreenShield.h'
--- lockscreen/KylinLockScreenShield.h	2015-12-07 03:09:28 +0000
+++ lockscreen/KylinLockScreenShield.h	2017-12-01 18:43:57 +0000
@@ -41,9 +41,6 @@
          nux::ObjectPtr<AbstractUserPromptView> const&,
          int monitor, bool is_primary);
 
-protected:
-  nux::Area* FindKeyFocusArea(unsigned int, unsigned long, unsigned long) override;
-
 private:
   void ShowPrimaryView() override;
 };
 
=== modified file 'lockscreen/KylinUserPromptView.cpp'
--- lockscreen/KylinUserPromptView.cpp	2016-03-31 05:57:11 +0000
+++ lockscreen/KylinUserPromptView.cpp	2017-12-01 18:43:57 +0000
@@ -79,9 +79,9 @@
 
 }
 
-KylinUserPromptView::KylinUserPromptView(session::Manager::Ptr const& session_manager)
-  : AbstractUserPromptView(session_manager)
-  , session_manager_(session_manager)
+KylinUserPromptView::KylinUserPromptView(session::Manager::Ptr const& session_manager,
+                                         UserAuthenticator::Ptr const& user_authenticator)
+  : AbstractUserPromptView(session_manager, user_authenticator)
   , username_(nullptr)
   , msg_layout_(nullptr)
   , prompt_layout_(nullptr)
@@ -90,25 +90,25 @@
   , avatar_(nullptr)
   , avatar_icon_file("")
 {
-    user_authenticator_.echo_on_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+    user_authenticator_->echo_on_requested.connect(sigc::track_obj([this](std::string const& message, PromiseAuthCodePtr const& promise){
         AddPrompt(message, true, promise);
-    });
+    }, *this));
 
-    user_authenticator_.echo_off_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+    user_authenticator_->echo_off_requested.connect(sigc::track_obj([this](std::string const& message, PromiseAuthCodePtr const& promise){
         AddPrompt(message, false, promise);
-    });
+    }, *this));
 
-    user_authenticator_.message_requested.connect([this](std::string const& message){
+    user_authenticator_->message_requested.connect(sigc::track_obj([this](std::string const& message){
         AddMessage(message, nux::color::White);
-    });
+    }, *this));
 
-    user_authenticator_.error_requested.connect([this](std::string const& message){
+    user_authenticator_->error_requested.connect(sigc::track_obj([this](std::string const& message){
         AddMessage(message, nux::color::Red);
-    });
+    }, *this));
 
-    user_authenticator_.clear_prompts.connect([this](){
+    user_authenticator_->clear_prompts.connect(sigc::track_obj([this](){
         ResetLayout();
-    });
+    }, *this));
 
     scale.changed.connect(sigc::hide(sigc::mem_fun(this, &KylinUserPromptView::UpdateSize)));
 
@@ -121,7 +121,7 @@
     ResetLayout();
 
     TextureCache::GetDefault().themed_invalidated.connect(sigc::mem_fun(this, &KylinUserPromptView::ResetLayout));
-    user_authenticator_.AuthenticateStart(session_manager_->UserName(),
+    user_authenticator_->AuthenticateStart(session_manager_->UserName(),
                                           sigc::mem_fun(this, &KylinUserPromptView::AuthenticationCb));
 }
 
@@ -244,7 +244,7 @@
   {
     AddMessage(_("Invalid password, please try again"), nux::color::Red);
 
-    user_authenticator_.AuthenticateStart(session_manager_->UserName(),
+    user_authenticator_->AuthenticateStart(session_manager_->UserName(),
                                           sigc::mem_fun(this, &KylinUserPromptView::AuthenticationCb));
   }
 }
 
=== modified file 'lockscreen/KylinUserPromptView.h'
--- lockscreen/KylinUserPromptView.h	2016-03-16 10:47:16 +0000
+++ lockscreen/KylinUserPromptView.h	2017-12-01 18:43:57 +0000
@@ -44,7 +44,8 @@
 class KylinUserPromptView : public AbstractUserPromptView
 {
 public:
-  KylinUserPromptView(session::Manager::Ptr const& session_manager);
+  KylinUserPromptView(session::Manager::Ptr const& session_manager,
+                      UserAuthenticator::Ptr const& user_authenticator);
 
   nux::View* focus_view();
 
@@ -62,8 +63,6 @@
   nux::ObjectPtr<nux::BaseTexture> LoadUserIcon(std::string const& icon_file, int icon_size);
 
 private:
-  session::Manager::Ptr session_manager_;
-  UserAuthenticatorPam user_authenticator_;
   StaticCairoText* username_;
   nux::VLayout* msg_layout_;
   nux::VLayout* prompt_layout_;
 
=== modified file 'lockscreen/LockScreenAbstractPromptView.h'
--- lockscreen/LockScreenAbstractPromptView.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenAbstractPromptView.h	2017-12-01 18:43:57 +0000
@@ -29,7 +29,7 @@
 #include <Nux/VLayout.h>
 #include "UnityCore/SessionManager.h"
 
-#include "UserAuthenticatorPam.h"
+#include "UserAuthenticator.h"
 #include "unity-shared/IMTextEntry.h"
 
 namespace nux
@@ -48,10 +48,12 @@
 class AbstractUserPromptView : public nux::View
 {
 public:
-  AbstractUserPromptView(session::Manager::Ptr const& session_manager)
+  AbstractUserPromptView(session::Manager::Ptr const& session_manager,
+                         UserAuthenticator::Ptr const& user_authenticator)
     : nux::View(NUX_TRACKER_LOCATION)
     , scale(1.0)
     , session_manager_(session_manager)
+    , user_authenticator_(user_authenticator)
   {}
 
   nux::Property<double> scale;
@@ -64,7 +66,7 @@
 
 protected:
   session::Manager::Ptr session_manager_;
-  UserAuthenticatorPam user_authenticator_;
+  UserAuthenticator::Ptr user_authenticator_;
   std::shared_ptr<nux::AbstractPaintLayer> bg_layer_;
   StaticCairoText* username_;
   nux::VLayout* msg_layout_;
 
=== modified file 'lockscreen/LockScreenBaseShield.cpp'
--- lockscreen/LockScreenBaseShield.cpp	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenBaseShield.cpp	2017-12-01 18:43:57 +0000
@@ -38,7 +38,6 @@
 }
 
 BaseShield::BaseShield(session::Manager::Ptr const& session,
-                       indicator::Indicators::Ptr const& indicators,
                        Accelerators::Ptr const& accelerators,
                        nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                        int monitor_num, bool is_primary)
@@ -47,7 +46,6 @@
   , monitor(monitor_num)
   , scale(1.0)
   , session_manager_(session)
-  , indicators_(indicators)
   , accelerators_(accelerators)
   , prompt_view_(prompt_view)
   , bg_settings_(std::make_shared<BackgroundSettings>())
@@ -83,11 +81,6 @@
     background_layer_.reset();
     UpdateBackgroundTexture();
   });
-
-  mouse_move.connect([this] (int x, int y, int, int, unsigned long, unsigned long) {
-    auto const& abs_geo = GetAbsoluteGeometry();
-    grab_motion.emit(abs_geo.x + x, abs_geo.y + y);
-  });
 }
 
 bool BaseShield::HasGrab() const
@@ -96,6 +89,19 @@
   return (wc.GetPointerGrabArea() == this && wc.GetKeyboardGrabArea() == this);
 }
 
+nux::Area* BaseShield::FindKeyFocusArea(unsigned etype, unsigned long keysym, unsigned long modifiers)
+{
+  if (primary && prompt_view_)
+  {
+    auto* focus_view = prompt_view_->focus_view();
+
+    if (focus_view && focus_view->GetInputEventSensitivity())
+      return focus_view;
+  }
+
+  return nullptr;
+}
+
 nux::Area* BaseShield::FindAreaUnderMouse(nux::Point const& mouse, nux::NuxEventType event_type)
 {
   nux::Area* area = BaseWindow::FindAreaUnderMouse(mouse, event_type);
@@ -139,6 +145,7 @@
   {
     auto background_texture = bg_settings_->GetBackgroundTexture(monitor);
     background_layer_.reset(new nux::TextureLayer(background_texture->GetDeviceTexture(), nux::TexCoordXForm(), nux::color::White, true));
+    background_layer_->SetGeometry(monitor_geo);
     SetBackgroundLayer(background_layer_.get());
   }
 }
 
=== modified file 'lockscreen/LockScreenBaseShield.h'
--- lockscreen/LockScreenBaseShield.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenBaseShield.h	2017-12-01 18:43:57 +0000
@@ -21,8 +21,8 @@
 #define UNITY_LOCKSCREEN_BASE_SHIELD_H
 
 #include <NuxCore/Property.h>
+#include "UnityCore/ConnectionManager.h"
 #include "UnityCore/SessionManager.h"
-#include "UnityCore/Indicators.h"
 #include "UnityCore/GLibSource.h"
 #include "unity-shared/MockableBaseWindow.h"
 
@@ -39,8 +39,8 @@
 class BaseShield : public MockableBaseWindow
 {
 public:
-  BaseShield(session::Manager::Ptr const&, indicator::Indicators::Ptr const&,
-             Accelerators::Ptr const&, nux::ObjectPtr<AbstractUserPromptView> const&,
+  BaseShield(session::Manager::Ptr const&, Accelerators::Ptr const&,
+             nux::ObjectPtr<AbstractUserPromptView> const&,
              int monitor_num, bool is_primary);
 
   nux::Property<bool> primary;
@@ -54,14 +54,13 @@
 
   sigc::signal<void> grabbed;
   sigc::signal<void> grab_failed;
-  sigc::signal<void, int, int> grab_motion;
-  sigc::signal<void, unsigned long, unsigned long> grab_key;
 
 protected:
   virtual bool AcceptKeyNavFocus() { return false; }
   virtual void ShowPrimaryView() = 0;
   virtual void ShowSecondaryView();
 
+  nux::Area* FindKeyFocusArea(unsigned int, unsigned long, unsigned long) override;
   nux::Area* FindAreaUnderMouse(nux::Point const& mouse, nux::NuxEventType event_type) override;
 
   void GrabScreen(bool cancel_on_failure);
@@ -69,7 +68,6 @@
   void UpdateScale();
 
   session::Manager::Ptr session_manager_;
-  indicator::Indicators::Ptr indicators_;
   Accelerators::Ptr accelerators_;
   nux::ObjectPtr<AbstractUserPromptView> prompt_view_;
   std::shared_ptr<BackgroundSettings> bg_settings_;
 
=== modified file 'lockscreen/LockScreenController.cpp'
--- lockscreen/LockScreenController.cpp	2016-07-05 10:22:42 +0000
+++ lockscreen/LockScreenController.cpp	2017-12-01 18:43:57 +0000
@@ -27,7 +27,9 @@
 #include "LockScreenPromptFactory.h"
 #include "LockScreenShield.h"
 #include "LockScreenSettings.h"
+#include "UserAuthenticatorPam.h"
 #include "unity-shared/AnimationUtils.h"
+#include "unity-shared/InputMonitor.h"
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/UScreen.h"
 #include "unity-shared/WindowManager.h"
@@ -66,10 +68,13 @@
   , upstart_wrapper_(upstart_wrapper)
   , shield_factory_(shield_factory)
   , suspend_inhibitor_manager_(std::make_shared<SuspendInhibitorManager>())
+  , user_authenticator_(std::make_shared<UserAuthenticatorPam>())
   , fade_animator_(unity::Settings::Instance().low_gfx() ? 0 : LOCK_FADE_DURATION)
   , blank_window_animator_(IDLE_FADE_DURATION)
   , test_mode_(test_mode)
   , prompt_activation_(false)
+  , is_paint_inhibited_(false)
+  , buffer_cleared_(true)
 {
   auto* uscreen = UScreen::GetDefault();
   uscreen_connection_ = uscreen->changed.connect([this] (int, std::vector<nux::Geometry> const& monitors) {
@@ -87,7 +92,13 @@
   suspend_inhibitor_manager_->connected.connect(sigc::mem_fun(this, &Controller::SyncInhibitor));
   suspend_inhibitor_manager_->about_to_suspend.connect([this] () {
     if (Settings::Instance().lock_on_suspend())
+    {
+      InhibitPaint();
       session_manager_->PromptLockScreen();
+    }
+  });
+  suspend_inhibitor_manager_->resumed.connect([this] () {
+    UninhibitPaint();
   });
 
   Settings::Instance().lock_on_suspend.changed.connect(sigc::hide(sigc::mem_fun(this, &Controller::SyncInhibitor)));
@@ -117,6 +128,8 @@
 
     if (animation::GetDirection(fade_animator_) == animation::Direction::BACKWARD)
     {
+      auto events_cb = sigc::track_obj(sigc::mem_fun(this, &Controller::OnLockScreenInputEvent), *primary_shield_);
+      input::Monitor::Get().UnregisterClient(events_cb);
       primary_shield_connections_.Clear();
       uscreen_connection_->block();
       hidden_window_connection_->block();
@@ -130,7 +143,7 @@
 
       upstart_wrapper_->Emit("desktop-unlock");
       accelerator_controller_.reset();
-      indicators_.reset();
+      menu_manager_.reset();
     }
     else if (!prompt_activation_)
     {
@@ -195,6 +208,20 @@
       break;
     }
   }
+}
+
+void Controller::OnLockScreenInputEvent(XEvent const& event)
+{
+  switch (event.type)
+  {
+    case MotionNotify:
+    case ButtonPress:
+      if (primary_shield_->IsIndicatorOpen())
+        break;
+    case ButtonRelease:
+      OnPrimaryShieldMotion(event.xmotion.x_root, event.xmotion.y_root);
+      break;
+  }
 
   ResetPostLockScreenSaver();
 }
@@ -206,11 +233,8 @@
 
   primary_shield_connections_.Clear();
 
-  auto move_cb = sigc::mem_fun(this, &Controller::OnPrimaryShieldMotion);
-  primary_shield_connections_.Add(primary_shield_->grab_motion.connect(move_cb));
-
-  auto key_cb = sigc::hide(sigc::hide(sigc::mem_fun(this, &Controller::ResetPostLockScreenSaver)));
-  primary_shield_connections_.Add(primary_shield_->grab_key.connect(key_cb));
+  auto events_cb = sigc::track_obj(sigc::mem_fun(this, &Controller::OnLockScreenInputEvent), *primary_shield_);
+  input::Monitor::Get().RegisterClient(input::Events::INPUT, events_cb);
 
   if (!session_manager_->is_locked())
   {
@@ -241,7 +265,7 @@
 
   if (!prompt_view)
   {
-    prompt_view = test_mode_ ? nux::ObjectPtr<AbstractUserPromptView>() : PromptFactory::CreatePrompt(session_manager_);
+    prompt_view = test_mode_ ? nux::ObjectPtr<AbstractUserPromptView>() : PromptFactory::CreatePrompt(session_manager_, user_authenticator_);
     prompt_view_ = prompt_view.GetPointer();
   }
 
@@ -252,7 +276,7 @@
 
     if (i >= shields_size)
     {
-      shield = shield_factory_->CreateShield(session_manager_, indicators_, accelerator_controller_->GetAccelerators(), prompt_view, i, i == primary);
+      shield = shield_factory_->CreateShield(session_manager_, menu_manager_, accelerator_controller_->GetAccelerators(), prompt_view, i, i == primary);
       is_new = true;
     }
 
@@ -314,10 +338,19 @@
   blank_window_->ShowWindow(false);
   animation::SetValue(blank_window_animator_, animation::Direction::BACKWARD);
 
+  if (prompt_activation_)
+    BlankWindowGrabEnable(false);
+
   blank_window_.Release();
   lockscreen_delay_timeout_.reset();
 }
 
+void Controller::OnBlankWindowInputEvent(XEvent const&)
+{
+  if (!lockscreen_timeout_)
+    HideBlankWindow();
+}
+
 void Controller::BlankWindowGrabEnable(bool grab)
 {
   if (!blank_window_)
@@ -325,41 +358,29 @@
 
   if (grab)
   {
-    for (auto const& shield : shields_)
+    if (!primary_shield_.IsValid())
     {
-      shield->UnGrabPointer();
-      shield->UnGrabKeyboard();
+      blank_window_->EnableInputWindow(true);
+      blank_window_->GrabPointer();
+      blank_window_->GrabKeyboard();
     }
 
-    blank_window_->EnableInputWindow(true);
-    blank_window_->GrabPointer();
-    blank_window_->GrabKeyboard();
+    input::Monitor::Get().RegisterClient(input::Events::INPUT, sigc::mem_fun(this, &Controller::OnBlankWindowInputEvent));
     nux::GetWindowCompositor().SetAlwaysOnFrontWindow(blank_window_.GetPointer());
-
-    blank_window_->mouse_move.connect([this](int, int, int dx, int dy, unsigned long, unsigned long) {
-      if ((dx || dy) && !lockscreen_timeout_) HideBlankWindow();
-    });
-    blank_window_->key_down.connect([this] (unsigned long et, unsigned long k, unsigned long s, const char* c, unsigned short kc) {
-      if (prompt_view_.GetPointer() && prompt_view_->focus_view())
-        prompt_view_->focus_view()->key_down.emit(et, k, s, c, kc);
-      if (!lockscreen_timeout_) HideBlankWindow();
-    });
-    blank_window_->mouse_down.connect([this] (int, int, unsigned long, unsigned long) {
-      if (!lockscreen_timeout_) HideBlankWindow();
-    });
   }
   else
   {
-    blank_window_->UnGrabPointer();
-    blank_window_->UnGrabKeyboard();
-
-    for (auto const& shield : shields_)
-    {
-      if (!shield->primary())
-        continue;
-
-      shield->GrabPointer();
-      shield->GrabKeyboard();
+    input::Monitor::Get().UnregisterClient(sigc::mem_fun(this, &Controller::OnBlankWindowInputEvent));
+
+    if (primary_shield_.IsValid())
+    {
+      primary_shield_->GrabPointer();
+      primary_shield_->GrabKeyboard();
+    }
+    else
+    {
+      blank_window_->UnGrabPointer();
+      blank_window_->UnGrabKeyboard();
     }
   }
 }
@@ -382,6 +403,7 @@
   if (prompt)
   {
     EnsureBlankWindow();
+    BlankWindowGrabEnable(true);
     blank_window_->SetOpacity(1.0);
   }
 
@@ -462,7 +484,8 @@
 
 void Controller::LockScreen()
 {
-  indicators_ = std::make_shared<indicator::LockScreenDBusIndicators>();
+  menu_manager_ = std::make_shared<menu::Manager>(std::make_shared<indicator::LockScreenDBusIndicators>(), key_grabber_);
+  menu_manager_->Indicators()->icon_paths_changed.clear(); // Ignore custom icon themes for lockscreen, see bug #1635625
   upstart_wrapper_->Emit("desktop-lock");
 
   accelerator_controller_ = std::make_shared<AcceleratorController>(key_grabber_);
@@ -536,6 +559,36 @@
   return primary_shield_.IsValid() ? primary_shield_->IsIndicatorOpen() : false;
 }
 
+void Controller::InhibitPaint()
+{
+  buffer_cleared_ = false;
+  is_paint_inhibited_ = true;
+}
+
+void Controller::UninhibitPaint()
+{
+  if (!is_paint_inhibited_)
+    return;
+
+  buffer_cleared_ = true;
+  is_paint_inhibited_ = false;
+  SyncInhibitor();
+}
+
+bool Controller::IsPaintInhibited() const
+{
+  return is_paint_inhibited_;
+}
+
+void Controller::MarkBufferHasCleared()
+{
+  if (buffer_cleared_)
+    return;
+
+  buffer_cleared_ = true;
+  SyncInhibitor();
+}
+
 void Controller::SyncInhibitor()
 {
   bool locked = IsLocked() && primary_shield_.IsValid() && primary_shield_->GetOpacity() == 1.0f;
@@ -546,7 +599,7 @@
 
   if (inhibit)
     suspend_inhibitor_manager_->Inhibit("Unity needs to lock the screen");
-  else
+  else if (buffer_cleared_)
     suspend_inhibitor_manager_->Uninhibit();
 }
 
 
=== modified file 'lockscreen/LockScreenController.h'
--- lockscreen/LockScreenController.h	2016-06-21 14:44:00 +0000
+++ lockscreen/LockScreenController.h	2017-12-01 18:43:57 +0000
@@ -29,8 +29,8 @@
 #include "LockScreenAcceleratorController.h"
 #include "SuspendInhibitorManager.h"
 #include "ScreenSaverDBusManager.h"
+#include "UserAuthenticator.h"
 #include "unity-shared/BackgroundEffectHelper.h"
-#include "unity-shared/KeyGrabber.h"
 #include "unity-shared/UpstartWrapper.h"
 
 namespace unity
@@ -54,6 +54,8 @@
 
   bool IsLocked() const;
   bool HasOpenMenu() const;
+  bool IsPaintInhibited() const;
+  void MarkBufferHasCleared();
 
 private:
   friend class TestLockScreenController;
@@ -77,6 +79,11 @@
   void OnPresenceStatusChanged(bool idle);
   void OnScreenSaverActivationRequest(bool activate);
   void OnPrimaryShieldMotion(int x, int y);
+  void OnLockScreenInputEvent(XEvent const&);
+  void OnBlankWindowInputEvent(XEvent const&);
+
+  void InhibitPaint();
+  void UninhibitPaint();
 
   std::vector<nux::ObjectPtr<BaseShield>> shields_;
   nux::ObjectWeakPtr<BaseShield> primary_shield_;
@@ -85,12 +92,13 @@
 
   DBusManager::Ptr dbus_manager_;
   session::Manager::Ptr session_manager_;
+  menu::Manager::Ptr menu_manager_;
   key::Grabber::Ptr key_grabber_;
-  indicator::Indicators::Ptr indicators_;
   AcceleratorController::Ptr accelerator_controller_;
   UpstartWrapper::Ptr upstart_wrapper_;
   ShieldFactoryInterface::Ptr shield_factory_;
   SuspendInhibitorManager::Ptr suspend_inhibitor_manager_;
+  UserAuthenticator::Ptr user_authenticator_;
 
   nux::animation::AnimateValue<double> fade_animator_;
   nux::animation::AnimateValue<double> blank_window_animator_;
@@ -98,6 +106,8 @@
   bool test_mode_;
   bool prompt_activation_;
   BlurType old_blur_type_;
+  bool is_paint_inhibited_;
+  bool buffer_cleared_;
 
   connection::Wrapper uscreen_connection_;
   connection::Wrapper hidden_window_connection_;
 
=== modified file 'lockscreen/LockScreenPanel.cpp'
--- lockscreen/LockScreenPanel.cpp	2015-11-05 14:55:54 +0000
+++ lockscreen/LockScreenPanel.cpp	2017-12-01 18:43:57 +0000
@@ -24,7 +24,7 @@
 
 #include "LockScreenSettings.h"
 #include "panel/PanelIndicatorsView.h"
-#include "unity-shared/CairoTexture.h"
+#include "unity-shared/InputMonitor.h"
 #include "unity-shared/StaticCairoText.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/RawPixel.h"
@@ -38,24 +38,24 @@
 namespace
 {
 const RawPixel PADDING = 5_em;
+const nux::Color BG_COLOR(0.1, 0.1, 0.1, 0.4);
 }
 
 using namespace indicator;
 using namespace panel;
 
-Panel::Panel(int monitor_, Indicators::Ptr const& indicators, session::Manager::Ptr const& session_manager)
+Panel::Panel(int monitor_, menu::Manager::Ptr const& menu_manager, session::Manager::Ptr const& session_manager)
   : nux::View(NUX_TRACKER_LOCATION)
   , active(false)
   , monitor(monitor_)
-  , indicators_(indicators)
+  , menu_manager_(menu_manager)
   , needs_geo_sync_(true)
 {
   double scale = unity::Settings::Instance().em(monitor)->DPIScale();
   auto* layout = new nux::HLayout();
   layout->SetLeftAndRightPadding(PADDING.CP(scale), 0);
   SetLayout(layout);
-
-  BuildTexture();
+  UpdateSize();
 
   // Add setting
   auto *hostname = new StaticCairoText(session_manager->HostName());
@@ -72,34 +72,33 @@
   indicators_view_->on_indicator_updated.connect(sigc::mem_fun(this, &Panel::OnIndicatorViewUpdated));
   layout->AddView(indicators_view_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
 
-  for (auto const& indicator : indicators_->GetIndicators())
+  auto indicators = menu_manager_->Indicators();
+  menu_manager_->RegisterTracker(GetPanelName(), (sigc::track_obj([this] (int x, int y, double speed) {
+    indicators_view_->ActivateEntryAt(x, y);
+  }, *this)));
+
+  for (auto const& indicator : indicators->GetIndicators())
     AddIndicator(indicator);
 
-  indicators_->on_object_added.connect(sigc::mem_fun(this, &Panel::AddIndicator));
-  indicators_->on_object_removed.connect(sigc::mem_fun(this, &Panel::RemoveIndicator));
-  indicators_->on_entry_show_menu.connect(sigc::mem_fun(this, &Panel::OnEntryShowMenu));
-  indicators_->on_entry_activated.connect(sigc::mem_fun(this, &Panel::OnEntryActivated));
-  indicators_->on_entry_activate_request.connect(sigc::mem_fun(this, &Panel::OnEntryActivateRequest));
+  indicators->on_object_added.connect(sigc::mem_fun(this, &Panel::AddIndicator));
+  indicators->on_object_removed.connect(sigc::mem_fun(this, &Panel::RemoveIndicator));
+  indicators->on_entry_show_menu.connect(sigc::mem_fun(this, &Panel::OnEntryShowMenu));
+  indicators->on_entry_activated.connect(sigc::mem_fun(this, &Panel::OnEntryActivated));
+  indicators->on_entry_activate_request.connect(sigc::mem_fun(this, &Panel::OnEntryActivateRequest));
 
   monitor.changed.connect([this, hostname] (int monitor) {
     double scale = unity::Settings::Instance().em(monitor)->DPIScale();
     hostname->SetScale(scale);
     static_cast<nux::HLayout*>(GetLayout())->SetLeftAndRightPadding(PADDING.CP(scale), 0);
     indicators_view_->SetMonitor(monitor);
-    BuildTexture();
+    UpdateSize();
     QueueRelayout();
   });
 }
 
-void Panel::BuildTexture()
+void Panel::UpdateSize()
 {
   int height = panel::Style::Instance().PanelHeight(monitor);
-  nux::CairoGraphics context(CAIRO_FORMAT_ARGB32, 1, height);
-  auto* cr = context.GetInternalContext();
-  cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
-  cairo_paint_with_alpha(cr, 0.4);
-  bg_texture_ = texture_ptr_from_cairo_graphics(context);
-
   view_layout_->SetMinimumHeight(height);
   view_layout_->SetMaximumHeight(height);
 }
@@ -150,7 +149,7 @@
 
 std::string Panel::GetPanelName() const
 {
-  return "LockScreenPanel";
+  return "LockScreenPanel" + std::to_string(reinterpret_cast<uintptr_t>(this));
 }
 
 void Panel::OnIndicatorViewUpdated()
@@ -165,12 +164,7 @@
   if (!GetInputEventSensitivity())
     return;
 
-  if (!active)
-  {
-    // This is ugly... But Nux fault!
-    WindowManager::Default().UnGrabMousePointer(CurrentTime, button, x, y);
-    active = true;
-  }
+  active = true;
 }
 
 void Panel::OnEntryActivateRequest(std::string const& entry_id)
@@ -184,36 +178,16 @@
   if (!GetInputEventSensitivity() || (!panel.empty() && panel != GetPanelName()))
     return;
 
-  bool active = !entry_id.empty();
+  bool valid_entry = !entry_id.empty();
 
-  if (active && !WindowManager::Default().IsScreenGrabbed())
+  if (valid_entry && !WindowManager::Default().IsScreenGrabbed())
   {
     // The menu didn't grab the keyboard, let's take it back.
     nux::GetWindowCompositor().GrabKeyboardAdd(static_cast<nux::BaseWindow*>(GetTopLevelViewWindow()));
   }
 
-  if (active && !track_menu_pointer_timeout_)
-  {
-    track_menu_pointer_timeout_.reset(new glib::Timeout(16));
-    track_menu_pointer_timeout_->Run([this] {
-      nux::Point const& mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-      if (tracked_pointer_pos_ != mouse)
-      {
-        if (GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y))
-          indicators_view_->ActivateEntryAt(mouse.x, mouse.y);
-
-        tracked_pointer_pos_ = mouse;
-      }
-
-      return true;
-    });
-  }
-  else if (!active)
-  {
-    track_menu_pointer_timeout_.reset();
-    tracked_pointer_pos_ = {-1, -1};
-    this->active = false;
-  }
+  if (!valid_entry)
+    active = valid_entry;
 }
 
 void Panel::Draw(nux::GraphicsEngine& graphics_engine, bool force_draw)
@@ -227,12 +201,7 @@
   graphics_engine.PushClippingRectangle(geo);
   nux::GetPainter().PaintBackground(graphics_engine, geo);
 
-  nux::TexCoordXForm texxform;
-  texxform.SetWrap(nux::TEXWRAP_REPEAT, nux::TEXWRAP_CLAMP);
-  graphics_engine.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                           bg_texture_->GetDeviceTexture(), texxform,
-                           nux::color::White);
-
+  graphics_engine.QRP_Color(geo.x, geo.y, geo.width, geo.height, BG_COLOR);
   view_layout_->ProcessDraw(graphics_engine, force_draw);
 
   graphics_engine.PopClippingRectangle();
@@ -242,7 +211,7 @@
   {
     EntryLocationMap locations;
     indicators_view_->GetGeometryForSync(locations);
-    indicators_->SyncGeometries(GetPanelName(), locations);
+    menu_manager_->Indicators()->SyncGeometries(GetPanelName(), locations);
     needs_geo_sync_ = false;
   }
 }
 
=== modified file 'lockscreen/LockScreenPanel.h'
--- lockscreen/LockScreenPanel.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenPanel.h	2017-12-01 18:43:57 +0000
@@ -22,9 +22,9 @@
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
-#include "UnityCore/Indicators.h"
 #include "UnityCore/GLibSource.h"
 #include "UnityCore/SessionManager.h"
+#include "unity-shared/MenuManager.h"
 
 namespace unity
 {
@@ -39,7 +39,7 @@
 class Panel : public nux::View
 {
 public:
-  Panel(int monitor, indicator::Indicators::Ptr const&, session::Manager::Ptr const&);
+  Panel(int monitor, menu::Manager::Ptr const&, session::Manager::Ptr const&);
 
   nux::Property<bool> active;
   nux::Property<int> monitor;
@@ -55,20 +55,16 @@
   void AddIndicator(indicator::Indicator::Ptr const&);
   void RemoveIndicator(indicator::Indicator::Ptr const&);
   void OnIndicatorViewUpdated();
-  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& geo);
+  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const&);
   void OnEntryShowMenu(std::string const& entry_id, unsigned xid, int x, int y, unsigned button);
   void OnEntryActivateRequest(std::string const& entry_id);
 
-  void BuildTexture();
+  void UpdateSize();
   std::string GetPanelName() const;
 
-  indicator::Indicators::Ptr indicators_;
+  menu::Manager::Ptr menu_manager_;
   panel::PanelIndicatorsView* indicators_view_;
-  nux::ObjectPtr<nux::BaseTexture> bg_texture_;
-
   bool needs_geo_sync_;
-  nux::Point tracked_pointer_pos_;
-  glib::Source::UniquePtr track_menu_pointer_timeout_;
 };
 
 } // lockscreen namespace
 
=== modified file 'lockscreen/LockScreenPromptFactory.cpp'
--- lockscreen/LockScreenPromptFactory.cpp	2015-12-04 08:17:46 +0000
+++ lockscreen/LockScreenPromptFactory.cpp	2017-12-01 18:43:57 +0000
@@ -26,14 +26,15 @@
 {
 namespace lockscreen
 {
-nux::ObjectPtr<AbstractUserPromptView> PromptFactory::CreatePrompt(session::Manager::Ptr const& sm)
+nux::ObjectPtr<AbstractUserPromptView> PromptFactory::CreatePrompt(session::Manager::Ptr const& sm,
+                                                                   UserAuthenticator::Ptr const& ua)
 {
   nux::ObjectPtr<AbstractUserPromptView> prompt;
 
   if (unity::Settings::Instance().desktop_type() == DesktopType::UBUNTUKYLIN)
-    prompt = new KylinUserPromptView(sm);
+    prompt = new KylinUserPromptView(sm, ua);
   else
-    prompt = new UserPromptView(sm);
+    prompt = new UserPromptView(sm, ua);
 
   return prompt;
 }
 
=== modified file 'lockscreen/LockScreenPromptFactory.h'
--- lockscreen/LockScreenPromptFactory.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenPromptFactory.h	2017-12-01 18:43:57 +0000
@@ -22,6 +22,7 @@
 
 #include <NuxCore/NuxCore.h>
 #include "UnityCore/SessionManager.h"
+#include "UserAuthenticator.h"
 
 namespace unity
 {
@@ -33,7 +34,8 @@
 
 struct PromptFactory
 {
-  static nux::ObjectPtr<AbstractUserPromptView> CreatePrompt(session::Manager::Ptr const&);
+  static nux::ObjectPtr<AbstractUserPromptView> CreatePrompt(session::Manager::Ptr const&,
+                                                             UserAuthenticator::Ptr const&);
 };
 
 }
 
=== modified file 'lockscreen/LockScreenShield.cpp'
--- lockscreen/LockScreenShield.cpp	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenShield.cpp	2017-12-01 18:43:57 +0000
@@ -32,11 +32,12 @@
 {
 
 Shield::Shield(session::Manager::Ptr const& session_manager,
-               indicator::Indicators::Ptr const& indicators,
+               menu::Manager::Ptr const& menu_manager,
                Accelerators::Ptr const& accelerators,
                nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                int monitor_num, bool is_primary)
-  : BaseShield(session_manager, indicators, accelerators, prompt_view, monitor_num, is_primary)
+  : BaseShield(session_manager, accelerators, prompt_view, monitor_num, is_primary)
+  , menu_manager_(menu_manager)
   , panel_view_(nullptr)
 {
   is_primary ? ShowPrimaryView() : ShowSecondaryView();
@@ -91,11 +92,11 @@
 
 Panel* Shield::CreatePanel()
 {
-  if (!indicators_ || !session_manager_)
+  if (!menu_manager_ || !session_manager_)
     return nullptr;
 
-  panel_view_ = new Panel(monitor, indicators_, session_manager_);
-  panel_active_conn_ = panel_view_->active.changed.connect([this] (bool active) {
+  panel_view_ = new Panel(monitor, menu_manager_, session_manager_);
+  panel_view_->active.changed.connect(sigc::track_obj([this] (bool active) {
     if (primary())
     {
       if (active)
@@ -109,7 +110,7 @@
         GrabScreen(false);
       }
     }
-  });
+  }, *this));
 
   return panel_view_;
 }
@@ -118,8 +119,6 @@
 {
   if (primary)
   {
-    grab_key.emit(modifiers, keysym);
-
     if (accelerators_)
     {
       if (etype == nux::EVENT_KEY_DOWN)
@@ -133,17 +132,9 @@
           return panel_view_;
       }
     }
-
-    if (prompt_view_)
-    {
-      auto* focus_view = prompt_view_->focus_view();
-
-      if (focus_view && focus_view->GetInputEventSensitivity())
-        return focus_view;
-    }
   }
 
-  return nullptr;
+  return BaseShield::FindKeyFocusArea(etype, keysym, modifiers);
 }
 
 bool Shield::IsIndicatorOpen() const
 
=== modified file 'lockscreen/LockScreenShield.h'
--- lockscreen/LockScreenShield.h	2015-12-03 14:13:10 +0000
+++ lockscreen/LockScreenShield.h	2017-12-01 18:43:57 +0000
@@ -20,8 +20,9 @@
 #ifndef UNITY_LOCKSCREEN_SHIELD_H
 #define UNITY_LOCKSCREEN_SHIELD_H
 
-#include <UnityCore/ConnectionManager.h>
 #include "LockScreenBaseShield.h"
+#include "unity-shared/MenuManager.h"
+
 
 namespace unity
 {
@@ -35,7 +36,7 @@
 {
 public:
   Shield(session::Manager::Ptr const&,
-         indicator::Indicators::Ptr const&,
+         menu::Manager::Ptr const&,
          Accelerators::Ptr const&,
          nux::ObjectPtr<AbstractUserPromptView> const&,
          int monitor, bool is_primary);
@@ -50,7 +51,7 @@
   void ShowPrimaryView() override;
   Panel* CreatePanel();
 
-  connection::Wrapper panel_active_conn_;
+  menu::Manager::Ptr menu_manager_;
   Panel* panel_view_;
 };
 
 
=== modified file 'lockscreen/LockScreenShieldFactory.cpp'
--- lockscreen/LockScreenShieldFactory.cpp	2015-12-04 08:17:46 +0000
+++ lockscreen/LockScreenShieldFactory.cpp	2017-12-01 18:43:57 +0000
@@ -28,7 +28,7 @@
 {
 
 nux::ObjectPtr<BaseShield> ShieldFactory::CreateShield(session::Manager::Ptr const& session_manager,
-                                                       indicator::Indicators::Ptr const& indicators,
+                                                       menu::Manager::Ptr const& menu_manager,
                                                        Accelerators::Ptr const& accelerators,
                                                        nux::ObjectPtr<AbstractUserPromptView> const& prompt_view,
                                                        int monitor, bool is_primary)
@@ -38,7 +38,7 @@
   if (Settings::Instance().desktop_type() == DesktopType::UBUNTUKYLIN)
     shield = new KylinShield(session_manager, accelerators, prompt_view, monitor, is_primary);
   else
-    shield = new Shield(session_manager, indicators, accelerators, prompt_view,  monitor, is_primary);
+    shield = new Shield(session_manager, menu_manager, accelerators, prompt_view,  monitor, is_primary);
 
   return shield;
 }
 
=== modified file 'lockscreen/LockScreenShieldFactory.h'
--- lockscreen/LockScreenShieldFactory.h	2016-03-31 09:51:33 +0000
+++ lockscreen/LockScreenShieldFactory.h	2017-12-01 18:43:57 +0000
@@ -22,7 +22,7 @@
 
 #include <NuxCore/NuxCore.h>
 #include "UnityCore/SessionManager.h"
-#include "UnityCore/Indicators.h"
+#include "unity-shared/MenuManager.h"
 #include "LockScreenAccelerators.h"
 
 namespace unity
@@ -41,7 +41,7 @@
   virtual ~ShieldFactoryInterface() = default;
 
   virtual nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
-                                                  indicator::Indicators::Ptr const&,
+                                                  menu::Manager::Ptr const&,
                                                   Accelerators::Ptr const&,
                                                   nux::ObjectPtr<AbstractUserPromptView> const&,
                                                   int monitor, bool is_primary) = 0;
@@ -50,7 +50,7 @@
 struct ShieldFactory : ShieldFactoryInterface
 {
   nux::ObjectPtr<BaseShield> CreateShield(session::Manager::Ptr const&,
-                                          indicator::Indicators::Ptr const&,
+                                          menu::Manager::Ptr const&,
                                           Accelerators::Ptr const&,
                                           nux::ObjectPtr<AbstractUserPromptView> const&,
                                           int monitor, bool is_primary) override;
 
=== modified file 'lockscreen/SuspendInhibitorManager.cpp'
--- lockscreen/SuspendInhibitorManager.cpp	2016-03-31 09:59:30 +0000
+++ lockscreen/SuspendInhibitorManager.cpp	2017-12-01 18:43:57 +0000
@@ -60,6 +60,8 @@
   lm_proxy_->Connect("PrepareForSleep", [this] (GVariant* variant) {
     if (glib::Variant(variant).GetBool())
       parent_->about_to_suspend.emit();
+    else
+      parent_->resumed.emit();
   });
 
   lm_proxy_->connected.connect(sigc::mem_fun(&parent->connected, &decltype(parent->connected)::emit));
 
=== modified file 'lockscreen/SuspendInhibitorManager.h'
--- lockscreen/SuspendInhibitorManager.h	2016-03-31 09:59:30 +0000
+++ lockscreen/SuspendInhibitorManager.h	2017-12-01 18:43:57 +0000
@@ -42,6 +42,7 @@
 
   sigc::signal<void> connected;
   sigc::signal<void> about_to_suspend;
+  sigc::signal<void> resumed;
 
 private:
   class Impl;
 
=== modified file 'lockscreen/UserAuthenticator.h'
--- lockscreen/UserAuthenticator.h	2014-03-05 04:09:13 +0000
+++ lockscreen/UserAuthenticator.h	2017-12-01 18:43:57 +0000
@@ -36,6 +36,7 @@
 class UserAuthenticator
 {
 public:
+  typedef std::shared_ptr<UserAuthenticator> Ptr;
   typedef std::function<void(bool)> AuthenticateEndCallback;
 
   virtual ~UserAuthenticator() = default;
@@ -43,6 +44,7 @@
   // Authenticate the user in a background thread.
   virtual bool AuthenticateStart(std::string const& username, AuthenticateEndCallback const&) = 0;
 
+  sigc::signal<void> start_failed;
   sigc::signal<void, std::string, PromiseAuthCodePtr const&> echo_on_requested;
   sigc::signal<void, std::string, PromiseAuthCodePtr const&> echo_off_requested;
   sigc::signal<void, std::string> message_requested;
 
=== modified file 'lockscreen/UserAuthenticatorPam.cpp'
--- lockscreen/UserAuthenticatorPam.cpp	2016-08-17 14:01:39 +0000
+++ lockscreen/UserAuthenticatorPam.cpp	2017-12-01 18:43:57 +0000
@@ -23,6 +23,7 @@
 
 #include "UserAuthenticatorPam.h"
 #include "unity-shared/UnitySettings.h"
+#include "UnityCore/GLibWrapper.h"
 
 #include <cstring>
 #include <security/pam_appl.h>
@@ -36,42 +37,49 @@
 bool UserAuthenticatorPam::AuthenticateStart(std::string const& username,
                                              AuthenticateEndCallback const& authenticate_cb)
 {
+  if (pam_handle_)
+    return false;
+
   first_prompt_ = true;
   username_ = username;
   authenticate_cb_ = authenticate_cb;
-  pam_handle_ = nullptr;
-
-  if (!InitPam() || !pam_handle_)
-    return false;
-
-  glib::Object<GTask> task(g_task_new(nullptr, cancellable_, [] (GObject*, GAsyncResult*, gpointer data) {
-    auto self = static_cast<UserAuthenticatorPam*>(data);
-    pam_end(self->pam_handle_, self->status_);
-    self->authenticate_cb_(self->status_ == PAM_SUCCESS);
-  }, this));
-
-  g_task_set_task_data(task, this, nullptr);
-
-  g_task_run_in_thread(task, [] (GTask* task, gpointer, gpointer data, GCancellable*) {
-    auto self = static_cast<UserAuthenticatorPam*>(data);
-
-    self->status_ = pam_authenticate(self->pam_handle_, 0);
-
-    if (self->status_ == PAM_SUCCESS)
-    {
-      int status2 = pam_acct_mgmt(self->pam_handle_, 0);
-
-      if (status2 == PAM_NEW_AUTHTOK_REQD)
-        status2 = pam_chauthtok(self->pam_handle_, PAM_CHANGE_EXPIRED_AUTHTOK);
-
-      if (unity::Settings::Instance().pam_check_account_type())
-        self->status_ = status2;
-
-      pam_setcred(self->pam_handle_, PAM_REINITIALIZE_CRED);
-    }
-  });
-
-  return true;
+
+  glib::Error error;
+  g_thread_try_new(nullptr, AuthenticationThreadFunc, this, &error);
+
+  return !error;
+}
+
+gpointer UserAuthenticatorPam::AuthenticationThreadFunc(gpointer data)
+{
+  auto self = static_cast<UserAuthenticatorPam*>(data);
+
+  if (!self->InitPam() || !self->pam_handle_)
+  {
+    self->pam_handle_ = nullptr;
+    self->source_manager_.AddTimeout(0, [self] { self->start_failed.emit(); return false; });
+    return nullptr;
+  }
+
+  self->status_ = pam_authenticate(self->pam_handle_, 0);
+
+  if (self->status_ == PAM_SUCCESS)
+  {
+    int status2 = pam_acct_mgmt(self->pam_handle_, 0);
+
+    if (status2 == PAM_NEW_AUTHTOK_REQD)
+      status2 = pam_chauthtok(self->pam_handle_, PAM_CHANGE_EXPIRED_AUTHTOK);
+
+    if (unity::Settings::Instance().pam_check_account_type())
+      self->status_ = status2;
+
+    pam_setcred(self->pam_handle_, PAM_REINITIALIZE_CRED);
+  }
+
+  pam_end(self->pam_handle_, self->status_);
+  self->pam_handle_ = nullptr;
+  self->source_manager_.AddTimeout(0, [self] {   self->authenticate_cb_(self->status_ == PAM_SUCCESS); return false; });
+  return nullptr;
 }
 
 bool UserAuthenticatorPam::InitPam()
 
=== modified file 'lockscreen/UserAuthenticatorPam.h'
--- lockscreen/UserAuthenticatorPam.h	2014-03-05 04:09:13 +0000
+++ lockscreen/UserAuthenticatorPam.h	2017-12-01 18:43:57 +0000
@@ -20,8 +20,6 @@
 #ifndef UNITY_USER_AUTHENTICATOR_PAM_H
 #define UNITY_USER_AUTHENTICATOR_PAM_H
 
-#include <boost/noncopyable.hpp>
-#include <UnityCore/GLibWrapper.h>
 #include <UnityCore/GLibSource.h>
 
 #include "UserAuthenticator.h"
@@ -36,13 +34,17 @@
 namespace lockscreen
 {
 
-class UserAuthenticatorPam : public UserAuthenticator, private boost::noncopyable
+class UserAuthenticatorPam : public UserAuthenticator
 {
 public:
+  UserAuthenticatorPam() = default;
   bool AuthenticateStart(std::string const& username, AuthenticateEndCallback const&) override;
 
 private:
-  // TODO (andy) move to pimpl
+  UserAuthenticatorPam(UserAuthenticatorPam const&) = delete;
+  UserAuthenticatorPam& operator=(UserAuthenticatorPam const&) = delete;
+
+  static gpointer AuthenticationThreadFunc(gpointer);
   bool InitPam();
 
   static int ConversationFunction(int num_msg,
@@ -53,10 +55,9 @@
   std::string username_;
   AuthenticateEndCallback authenticate_cb_;
 
-  int status_;
-  bool first_prompt_;
-  pam_handle* pam_handle_;
-  glib::Cancellable cancellable_;
+  int status_ = 0;
+  bool first_prompt_ = true;
+  pam_handle* pam_handle_ = nullptr;
   glib::SourceManager source_manager_;
 };
 
 
=== modified file 'lockscreen/UserPromptView.cpp'
--- lockscreen/UserPromptView.cpp	2016-06-28 16:23:27 +0000
+++ lockscreen/UserPromptView.cpp	2017-12-01 18:43:57 +0000
@@ -23,6 +23,7 @@
 #include <glib/gi18n-lib.h>
 
 #include <boost/algorithm/string/trim.hpp>
+#include <NuxCore/Logger.h>
 #include <Nux/VLayout.h>
 
 #include "LockScreenSettings.h"
@@ -38,6 +39,9 @@
 {
 namespace
 {
+
+DECLARE_LOGGER(logger, "unity.lockscreen");
+
 const RawPixel PADDING              = 10_em;
 const RawPixel LAYOUT_MARGIN        = 10_em;
 const RawPixel MSG_LAYOUT_MARGIN    = 15_em;
@@ -101,41 +105,46 @@
 
 }
 
-UserPromptView::UserPromptView(session::Manager::Ptr const& session_manager)
-  : AbstractUserPromptView(session_manager)
-  , session_manager_(session_manager)
+UserPromptView::UserPromptView(session::Manager::Ptr const& session_manager,
+                               UserAuthenticator::Ptr const& user_authenticator)
+  : AbstractUserPromptView(session_manager, user_authenticator)
   , username_(nullptr)
   , msg_layout_(nullptr)
   , prompt_layout_(nullptr)
   , button_layout_(nullptr)
   , prompted_(false)
   , unacknowledged_messages_(false)
+  , num_retry_auth_(0)
 {
-  user_authenticator_.echo_on_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+  user_authenticator_->start_failed.connect(sigc::track_obj([this](){
+    HandleAuthenticationStartFailure();
+  }, *this));
+
+  user_authenticator_->echo_on_requested.connect(sigc::track_obj([this](std::string const& message, PromiseAuthCodePtr const& promise){
     prompted_ = true;
     unacknowledged_messages_ = false;
     AddPrompt(message, /* visible */ true, promise);
-  });
+  }, *this));
 
-  user_authenticator_.echo_off_requested.connect([this](std::string const& message, PromiseAuthCodePtr const& promise){
+  user_authenticator_->echo_off_requested.connect(sigc::track_obj([this](std::string const& message, PromiseAuthCodePtr const& promise){
     prompted_ = true;
     unacknowledged_messages_ = false;
     AddPrompt(message, /* visible */ false, promise);
-  });
+  }, *this));
 
-  user_authenticator_.message_requested.connect([this](std::string const& message){
+  user_authenticator_->message_requested.connect(sigc::track_obj([this](std::string const& message){
     unacknowledged_messages_ = true;
     AddMessage(message, nux::color::White);
-  });
+  }, *this));
 
-  user_authenticator_.error_requested.connect([this](std::string const& message){
+  user_authenticator_->error_requested.connect(sigc::track_obj([this](std::string const& message){
     unacknowledged_messages_ = true;
     AddMessage(message, nux::color::Red);
-  });
+  }, *this));
 
-  user_authenticator_.clear_prompts.connect([this](){
+  user_authenticator_->clear_prompts.connect(sigc::track_obj([this](){
     ResetLayout();
-  });
+  }, *this));
 
   scale.changed.connect(sigc::hide(sigc::mem_fun(this, &UserPromptView::UpdateSize)));
 
@@ -469,13 +478,40 @@
   prompted_ = false;
   unacknowledged_messages_ = false;
 
-  user_authenticator_.AuthenticateStart(session_manager_->UserName(),
-                                        sigc::mem_fun(this, &UserPromptView::AuthenticationCb));
+  if(!user_authenticator_->AuthenticateStart(session_manager_->UserName(),
+                                             sigc::mem_fun(this, &UserPromptView::AuthenticationCb)))
+  {
+    HandleAuthenticationStartFailure();
+  }
 }
 
 void UserPromptView::DoUnlock()
 {
   session_manager_->unlock_requested.emit();
+  num_retry_auth_ = 0;
+}
+
+void UserPromptView::HandleAuthenticationStartFailure()
+{
+  ++num_retry_auth_;
+
+  if (num_retry_auth_ <= 5)
+  {
+    LOG_WARNING(logger) << "Failed to start the authentication process. Retrying for " << num_retry_auth_ << " time.";
+    source_manager_.AddTimeout(100, [this] {
+      StartAuthentication();
+      return false;
+    });
+  }
+  else
+  {
+    AddMessage(_("Authentication failure"), nux::color::Red);
+    AddButton(_("Switch to greeter…"), [this] {
+      session_manager_->SwitchToGreeter();
+    });
+
+    GetLayout()->AddLayout(button_layout_);
+  }
 }
 
 }
 
=== modified file 'lockscreen/UserPromptView.h'
--- lockscreen/UserPromptView.h	2016-06-28 16:23:27 +0000
+++ lockscreen/UserPromptView.h	2017-12-01 18:43:57 +0000
@@ -25,10 +25,10 @@
 
 #include <Nux/Nux.h>
 #include <Nux/View.h>
+#include "UnityCore/GLibSource.h"
 #include "UnityCore/SessionManager.h"
 
 #include "LockScreenAbstractPromptView.h"
-#include "UserAuthenticatorPam.h"
 #include "unity-shared/IMTextEntry.h"
 
 namespace nux
@@ -48,7 +48,8 @@
 class UserPromptView : public AbstractUserPromptView
 {
 public:
-  UserPromptView(session::Manager::Ptr const& session_manager);
+  UserPromptView(session::Manager::Ptr const& session_manager,
+                 UserAuthenticator::Ptr const& user_authenticator);
 
   nux::View* focus_view();
 
@@ -70,9 +71,8 @@
   void ShowAuthenticated(bool successful);
   void StartAuthentication();
   void DoUnlock();
+  void HandleAuthenticationStartFailure();
 
-  session::Manager::Ptr session_manager_;
-  UserAuthenticatorPam user_authenticator_;
   std::shared_ptr<nux::AbstractPaintLayer> bg_layer_;
   StaticCairoText* username_;
   nux::VLayout* msg_layout_;
@@ -84,6 +84,9 @@
 
   bool prompted_;
   bool unacknowledged_messages_;
+  int num_retry_auth_ = 0;
+
+  glib::SourceManager source_manager_;
 };
 
 }
 
=== modified file 'panel/PanelController.cpp'
--- panel/PanelController.cpp	2014-07-30 00:49:35 +0000
+++ panel/PanelController.cpp	2017-12-01 18:43:57 +0000
@@ -33,9 +33,8 @@
 
 const char* window_title = "unity-panel";
 
-class Controller::Impl
+struct Controller::Impl : sigc::trackable
 {
-public:
   Impl(Controller*, menu::Manager::Ptr const&, ui::EdgeBarrierController::Ptr const&);
   ~Impl();
 
 
=== modified file 'panel/PanelIndicatorEntryView.cpp'
--- panel/PanelIndicatorEntryView.cpp	2016-02-17 13:14:37 +0000
+++ panel/PanelIndicatorEntryView.cpp	2017-12-01 18:43:57 +0000
@@ -33,6 +33,8 @@
 #include "unity-shared/RawPixel.h"
 #include "unity-shared/WindowManager.h"
 #include "unity-shared/ThemeSettings.h"
+#include "unity-shared/UBusWrapper.h"
+#include "unity-shared/UBusMessages.h"
 #include "unity-shared/UnitySettings.h"
 
 namespace unity
@@ -117,6 +119,9 @@
     }
     else
     {
+      if (overlay_showing_)
+        UBusManager::SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
+
       WindowManager& wm = WindowManager::Default();
 
       if (wm.IsExpoActive())
@@ -140,6 +145,11 @@
         wm.TerminateScale();
       }
 
+      // This is ugly... But Nux fault!
+      auto const& abs_geo = GetAbsoluteGeometry();
+      guint64 timestamp = nux::GetGraphicsDisplay()->GetCurrentEvent().x11_timestamp;
+      WindowManager::Default().UnGrabMousePointer(timestamp, button, abs_geo.x, abs_geo.y);
+
       Activate(button);
     }
   }
 
=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2016-09-01 23:56:04 +0000
+++ panel/PanelMenuView.cpp	2017-12-01 18:43:57 +0000
@@ -102,7 +102,6 @@
   , ignore_menu_visibility_(false)
   , integrated_menus_(menu_manager_->integrated_menus())
   , always_show_menus_(menu_manager_->always_show_menus())
-  , ignore_leave_events_(false)
   , desktop_name_(get_current_desktop())
 {
   if (ApplicationWindowPtr const& win = ApplicationManager::Default().GetActiveWindow())
@@ -1814,14 +1813,9 @@
   }
 }
 
-void PanelMenuView::IgnoreLeaveEvents(bool ignore)
-{
-  ignore_leave_events_ = ignore;
-}
-
 void PanelMenuView::OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state)
 {
-  if (always_show_menus_ || ignore_leave_events_)
+  if (always_show_menus_)
     return;
 
   if (is_inside_)
 
=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2015-11-05 14:54:13 +0000
+++ panel/PanelMenuView.h	2017-12-01 18:43:57 +0000
@@ -56,7 +56,6 @@
   bool HasKeyActivableMenus() const;
 
   void NotifyAllMenusClosed();
-  void IgnoreLeaveEvents(bool);
 
   virtual void AddIndicator(indicator::Indicator::Ptr const& indicator);
 
@@ -192,7 +191,6 @@
   bool ignore_menu_visibility_;
   bool integrated_menus_;
   bool always_show_menus_;
-  bool ignore_leave_events_;
 
   nux::Geometry monitor_geo_;
   const std::string desktop_name_;
 
=== modified file 'panel/PanelView.cpp'
--- panel/PanelView.cpp	2016-08-17 14:02:12 +0000
+++ panel/PanelView.cpp	2017-12-01 18:43:57 +0000
@@ -42,7 +42,8 @@
 namespace
 {
 const RawPixel TRIANGLE_THRESHOLD = 5_em;
-const int refine_gradient_midpoint = 959;
+const double SCRUB_VELOCITY_THRESHOLD = 0.05;
+const RawPixel REFINE_GRADIENT_MIDPOINT = 959;
 }
 
 
@@ -51,7 +52,8 @@
 PanelView::PanelView(MockableBaseWindow* parent, menu::Manager::Ptr const& menus, NUX_FILE_LINE_DECL)
   : View(NUX_FILE_LINE_PARAM)
   , parent_(parent)
-  , remote_(menus->Indicators())
+  , menus_(menus)
+  , remote_(menus_->Indicators())
   , is_dirty_(true)
   , opacity_maximized_toggle_(false)
   , needs_geo_sync_(false)
@@ -113,10 +115,9 @@
 
   remote_->on_object_added.connect(sigc::mem_fun(this, &PanelView::OnObjectAdded));
   remote_->on_object_removed.connect(sigc::mem_fun(this, &PanelView::OnObjectRemoved));
-  remote_->on_entry_activated.connect(sigc::mem_fun(this, &PanelView::OnEntryActivated));
-  remote_->on_entry_show_menu.connect(sigc::mem_fun(this, &PanelView::OnEntryShowMenu));
   menus->key_activate_entry.connect(sigc::mem_fun(this, &PanelView::ActivateEntry));
   menus->open_first.connect(sigc::mem_fun(this, &PanelView::ActivateFirstSensitive));
+  menus->RegisterTracker(GetPanelName(), sigc::mem_fun(this, &PanelView::OnMenuPointerMoved));
 
   ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &PanelView::OnOverlayHidden));
   ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &PanelView::OnOverlayShown));
@@ -134,7 +135,7 @@
 PanelView::~PanelView()
 {
   indicator::EntryLocationMap locations;
-  remote_->SyncGeometries(GetName() + std::to_string(monitor_), locations);
+  remote_->SyncGeometries(GetPanelName(), locations);
 }
 
 void PanelView::LoadTextures()
@@ -374,7 +375,7 @@
       GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
       nux::TexCoordXForm refine_texxform;
 
-      int refine_x_pos = geo.x + (stored_dash_width_ - refine_gradient_midpoint);
+      int refine_x_pos = geo.x + (stored_dash_width_ - REFINE_GRADIENT_MIDPOINT.CP(Settings::Instance().em(monitor_)));
 
       if (Settings::Instance().launcher_position() == LauncherPosition::LEFT)
         refine_x_pos += unity::Settings::Instance().LauncherSize(monitor_);
@@ -473,7 +474,7 @@
 
       nux::Geometry refine_geo = geo;
 
-      int refine_x_pos = geo.x + (stored_dash_width_ - refine_gradient_midpoint);
+      int refine_x_pos = geo.x + (stored_dash_width_ - REFINE_GRADIENT_MIDPOINT.CP(Settings::Instance().em(monitor_)));
       if (Settings::Instance().launcher_position() == LauncherPosition::LEFT)
         refine_x_pos += unity::Settings::Instance().LauncherSize(monitor_);
 
@@ -627,7 +628,7 @@
   QueueDraw();
 }
 
-void PanelView::OnMenuPointerMoved(int x, int y)
+void PanelView::OnMenuPointerMoved(int x, int y, double speed)
 {
   nux::Geometry const& geo = GetAbsoluteGeometry();
 
@@ -648,116 +649,6 @@
   }
 }
 
-static bool PointInTriangle(nux::Point const& p, nux::Point const& t0, nux::Point const& t1, nux::Point const& t2)
-{
-  int s = t0.y * t2.x - t0.x * t2.y + (t2.y - t0.y) * p.x + (t0.x - t2.x) * p.y;
-  int t = t0.x * t1.y - t0.y * t1.x + (t0.y - t1.y) * p.x + (t1.x - t0.x) * p.y;
-
-  if ((s < 0) != (t < 0))
-    return false;
-
-  int A = -t1.y * t2.x + t0.y * (t2.x - t1.x) + t0.x * (t1.y - t2.y) + t1.x * t2.y;
-  if (A < 0)
-  {
-    s = -s;
-    t = -t;
-    A = -A;
-  }
-
-  return s > 0 && t > 0 && (s + t) < A;
-}
-
-static double GetMouseVelocity(nux::Point const& p0, nux::Point const& p1, util::Timer &timer)
-{
-  int dx, dy;
-  double speed;
-  auto millis = timer.ElapsedMicroSeconds();
-
-  if (millis == 0)
-    return 1;
-
-  dx = p0.x - p1.x;
-  dy = p0.y - p1.y;
-
-  speed = sqrt(dx * dx + dy * dy) / millis * 1000;
-
-  return speed;
-}
-
-bool PanelView::TrackMenuPointer()
-{
-  nux::Point const& mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-  double speed = GetMouseVelocity(mouse, tracked_pointer_pos_, mouse_tracker_timer_);
-
-  mouse_tracker_timer_.Reset();
-  tracked_pointer_pos_ = mouse;
-
-  double scale = Settings::Instance().em(monitor_)->DPIScale();
-  if (speed > 0 && PointInTriangle(mouse,
-                                   nux::Point(triangle_top_corner_.x, std::max(triangle_top_corner_.y - TRIANGLE_THRESHOLD.CP(scale), 0)),
-                                   nux::Point(menu_geo_.x, menu_geo_.y),
-                                   nux::Point(menu_geo_.x + menu_geo_.width, menu_geo_.y)))
-  {
-    return true;
-  }
-
-  if (mouse != triangle_top_corner_)
-  {
-    triangle_top_corner_ = mouse;
-    OnMenuPointerMoved(mouse.x, mouse.y);
-  }
-
-  return true;
-}
-
-void PanelView::OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& menu_geo)
-{
-  if (!panel.empty() && panel != GetPanelName())
-    return;
-
-  menu_geo_ = menu_geo;
-
-  bool active = !entry_id.empty();
-  if (active && !track_menu_pointer_timeout_)
-  {
-    //
-    // Track menus being scrubbed at 60Hz (about every 16 millisec)
-    // It might sound ugly, but it's far nicer (and more responsive) than the
-    // code it replaces which used to capture motion events in another process
-    // (unity-panel-service) and send them to us over dbus.
-    // NOTE: The reason why we have to use a timer instead of tracking motion
-    // events is because the motion events will never be delivered to this
-    // process. All the motion events will go to unity-panel-service while
-    // scrubbing because the active panel menu has (needs) the pointer grab.
-    //
-    mouse_tracker_timer_.Reset();
-    triangle_top_corner_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-    track_menu_pointer_timeout_.reset(new glib::Timeout(16));
-    track_menu_pointer_timeout_->Run(sigc::mem_fun(this, &PanelView::TrackMenuPointer));
-  }
-  else if (!active)
-  {
-    track_menu_pointer_timeout_.reset();
-    menu_view_->NotifyAllMenusClosed();
-    tracked_pointer_pos_ = {-1, -1};
-  }
-
-  if (overlay_is_open_)
-    ubus_manager_.SendMessage(UBUS_OVERLAY_CLOSE_REQUEST);
-}
-
-void PanelView::OnEntryShowMenu(std::string const& entry_id, unsigned xid,
-                                int x, int y, unsigned button)
-{
-  if (!track_menu_pointer_timeout_)
-  {
-    // This is ugly... But Nux fault!
-    menu_view_->IgnoreLeaveEvents(true);
-    WindowManager::Default().UnGrabMousePointer(CurrentTime, button, x, y);
-    menu_view_->IgnoreLeaveEvents(false);
-  }
-}
-
 bool PanelView::ActivateFirstSensitive()
 {
   if (!IsActive())
@@ -768,7 +659,6 @@
   {
     // Since this only happens on keyboard events, we need to prevent that the
     // pointer tracker would select another entry.
-    tracked_pointer_pos_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     return true;
   }
 
@@ -785,7 +675,6 @@
   {
     // Since this only happens on keyboard events, we need to prevent that the
     // pointer tracker would select another entry.
-    tracked_pointer_pos_ = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     return true;
   }
 
@@ -847,7 +736,7 @@
 
 std::string PanelView::GetPanelName() const
 {
-  return GetName() + std::to_string(monitor_);
+  return GetName() + std::to_string(reinterpret_cast<uintptr_t>(this)) + '_' + std::to_string(monitor_);
 }
 
 void PanelView::SyncGeometries()
@@ -863,9 +752,13 @@
 
 void PanelView::SetMonitor(int monitor)
 {
+  auto mouse_tracker_cb = sigc::mem_fun(this, &PanelView::OnMenuPointerMoved);
+  menus_->UnregisterTracker(GetPanelName(), mouse_tracker_cb);
+
   monitor_ = monitor;
   menu_view_->SetMonitor(monitor);
   indicators_->SetMonitor(monitor);
+  menus_->RegisterTracker(GetPanelName(), mouse_tracker_cb);
   Resize();
 
   if (WindowManager::Default().IsScaleActive())
 
=== modified file 'panel/PanelView.h'
--- panel/PanelView.h	2016-03-30 18:18:07 +0000
+++ panel/PanelView.h	2017-12-01 18:43:57 +0000
@@ -35,7 +35,6 @@
 #include "unity-shared/Introspectable.h"
 #include "unity-shared/MenuManager.h"
 #include "unity-shared/MockableBaseWindow.h"
-#include "unity-shared/Timer.h"
 #include "PanelMenuView.h"
 #include "PanelTray.h"
 #include "PanelIndicatorsView.h"
@@ -88,9 +87,6 @@
   void OnObjectAdded(indicator::Indicator::Ptr const& proxy);
   void OnObjectRemoved(indicator::Indicator::Ptr const& proxy);
   void OnIndicatorViewUpdated();
-  void OnMenuPointerMoved(int x, int y);
-  void OnEntryActivated(std::string const& panel, std::string const& entry_id, nux::Rect const& geo);
-  void OnEntryShowMenu(std::string const& entry_id, unsigned xid, int x, int y, unsigned button);
 
 private:
   std::string GetPanelName() const;
@@ -100,6 +96,8 @@
   void OnSpreadInitiate();
   void OnSpreadTerminate();
   void OnLowGfxChanged();
+  void OnMenuPointerMoved(int x, int y, double speed);
+  void OnActiveEntryEvent(XEvent const&);
   void EnableOverlayMode(bool);
   void LoadTextures();
 
@@ -109,11 +107,11 @@
   bool IsTransparent();
   void UpdateBackground();
   void ForceUpdateBackground();
-  bool TrackMenuPointer();
   void SyncGeometries();
   void AddPanelView(PanelIndicatorsView* child, unsigned int stretchFactor);
 
   MockableBaseWindow* parent_;
+  menu::Manager::Ptr menus_;
   indicator::Indicators::Ptr remote_;
 
   // No ownership is taken for these views, that is done by the AddChild method.
@@ -133,10 +131,6 @@
   BaseTexturePtr bg_refine_single_column_tex_;
   std::unique_ptr<nux::AbstractPaintLayer> bg_refine_single_column_layer_;
 
-  std::string active_overlay_;
-  nux::Point  tracked_pointer_pos_, triangle_top_corner_;
-  util::Timer mouse_tracker_timer_;
-
   bool is_dirty_;
   bool opacity_maximized_toggle_;
   bool needs_geo_sync_;
@@ -144,15 +138,13 @@
   float opacity_;
   int monitor_;
   int stored_dash_width_;
-
-  nux::Geometry menu_geo_;
+  std::string active_overlay_;
 
   connection::Manager on_indicator_updated_connections_;
   connection::Manager maximized_opacity_toggle_connections_;
   BackgroundEffectHelper bg_effect_helper_;
   nux::ObjectPtr<nux::IOpenGLBaseTexture> bg_blur_texture_;
   UBusManager ubus_manager_;
-  glib::Source::UniquePtr track_menu_pointer_timeout_;
 };
 
 } // namespace panel
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2016-09-01 23:56:16 +0000
+++ plugins/unityshell/src/unityshell.cpp	2017-12-01 18:43:57 +0000
@@ -197,6 +197,7 @@
   , menus_(std::make_shared<menu::Manager>(std::make_shared<indicator::DBusIndicators>(), std::make_shared<key::GnomeGrabber>()))
   , deco_manager_(std::make_shared<decoration::Manager>(menus_))
   , debugger_(this)
+  , session_(std::make_shared<session::GnomeManager>())
   , needsRelayout(false)
   , super_keypressed_(false)
   , newFocusedWindow(nullptr)
@@ -291,23 +292,22 @@
     }
   }
 
-    //In case of software rendering then enable lowgfx mode.
+  //In case of software rendering then enable lowgfx mode.
+  std::string lowgfx_env = glib::gchar_to_string(getenv("UNITY_LOW_GFX_MODE"));
   std::string renderer = ANSI_TO_TCHAR(NUX_REINTERPRET_CAST(const char *, glGetString(GL_RENDERER)));
-
   if (renderer.find("Software Rasterizer") != std::string::npos ||
       renderer.find("Mesa X11") != std::string::npos ||
       renderer.find("llvmpipe") != std::string::npos ||
       renderer.find("softpipe") != std::string::npos ||
-      (getenv("UNITY_LOW_GFX_MODE") != NULL && atoi(getenv("UNITY_LOW_GFX_MODE")) == 1) ||
-       optionGetLowGraphicsMode())
-    {
-      unity_settings_.low_gfx = true;
-    }
-
-  if (getenv("UNITY_LOW_GFX_MODE") != NULL && atoi(getenv("UNITY_LOW_GFX_MODE")) == 0)
+      atoi(lowgfx_env.c_str()) == 1)
   {
-    unity_settings_.low_gfx = false;
+    if (lowgfx_env.empty() || atoi(lowgfx_env.c_str()) != 0)
+      unity_settings_.supports_3d = false;
   }
+
+  Settings::Instance().low_gfx.changed.connect(sigc::track_obj([this] (bool low_gfx) {
+    BackgroundEffectHelper::blur_type = low_gfx ? BLUR_NONE : (unity::BlurType) optionGetDashBlurExperimental();
+  }, *this));
 #endif
 
   if (!failed)
@@ -383,7 +383,6 @@
      optionSetAutohideAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetDashBlurExperimentalNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShortcutOverlayNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
-     optionSetLowGraphicsModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowLauncherInitiate(boost::bind(&UnityScreen::showLauncherKeyInitiate, this, _1, _2, _3));
      optionSetShowLauncherTerminate(boost::bind(&UnityScreen::showLauncherKeyTerminate, this, _1, _2, _3));
      optionSetKeyboardFocusInitiate(boost::bind(&UnityScreen::setKeyboardFocusKeyInitiate, this, _1, _2, _3));
@@ -477,9 +476,10 @@
 
     Introspectable::AddChild(deco_manager_.get());
     auto const& deco_style = decoration::Style::Get();
-    auto deco_style_cb = sigc::hide(sigc::mem_fun(this, &UnityScreen::OnDecorationStyleChanged));
+    auto deco_style_cb = sigc::hide(sigc::mem_fun(this, &UnityScreen::UpdateDecorationStyle));
     deco_style->theme.changed.connect(deco_style_cb);
     deco_style->title_font.changed.connect(deco_style_cb);
+    UpdateDecorationStyle();
 
     minimize_speed_controller_.DurationChanged.connect(
       sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
@@ -515,7 +515,10 @@
   unity_a11y_finalize();
   QuicklistManager::Destroy();
   decoration::DataPool::Reset();
-  SaveLockStamp(false);
+
+  if (!session_->AutomaticLogin())
+    SaveLockStamp(false);
+
   reset_glib_logging();
 
   screen->addSupportedAtomsSetEnabled(this, false);
@@ -583,12 +586,14 @@
 
       for (auto const& swin : sScreen->getWindows())
       {
-        if (filtered_windows.find(swin->window->id()) != filtered_windows.end())
+        if (!swin->window || filtered_windows.find(swin->window->id()) != filtered_windows.end())
           continue;
 
-        auto* uwin = UnityWindow::get(swin->window);
-        uwin->OnTerminateSpread();
-        fake_decorated_windows_.erase(uwin);
+        if (UnityWindow* uwin = UnityWindow::get(swin->window))
+        {
+          uwin->OnTerminateSpread();
+          fake_decorated_windows_.erase(uwin);
+        }
       }
 
       for (auto xid : filtered_windows)
@@ -602,6 +607,9 @@
 
   for (auto const& swin : sScreen->getWindows())
   {
+    if (!swin->window)
+      continue;
+
     auto* uwin = UnityWindow::get(swin->window);
     fake_decorated_windows_.insert(uwin);
     uwin->OnInitiateSpread();
@@ -613,7 +621,13 @@
   spread_widgets_.reset();
 
   for (auto const& swin : sScreen->getWindows())
-    UnityWindow::get(swin->window)->OnTerminateSpread();
+  {
+    if (!swin->window)
+      continue;
+
+    if (UnityWindow* uwin = UnityWindow::get(swin->window))
+      uwin->OnTerminateSpread();
+  }
 
   fake_decorated_windows_.clear();
 }
@@ -845,17 +859,28 @@
   wy = y + (last_bound.height - height) / 2;
 }
 
-void UnityScreen::OnDecorationStyleChanged()
+void UnityScreen::UpdateDecorationStyle()
 {
   for (UnityWindow* uwin : fake_decorated_windows_)
     uwin->CleanupCachedTextures();
 
-  auto const& style = decoration::Style::Get();
-  deco_manager_->shadow_offset = style->ShadowOffset();
-  deco_manager_->active_shadow_color = style->ActiveShadowColor();
-  deco_manager_->active_shadow_radius = style->ActiveShadowRadius();
-  deco_manager_->inactive_shadow_color = style->InactiveShadowColor();
-  deco_manager_->inactive_shadow_radius = style->InactiveShadowRadius();
+  if (optionGetOverrideDecorationTheme())
+  {
+    deco_manager_->active_shadow_color = NuxColorFromCompizColor(optionGetActiveShadowColor());
+    deco_manager_->inactive_shadow_color = NuxColorFromCompizColor(optionGetInactiveShadowColor());
+    deco_manager_->active_shadow_radius = optionGetActiveShadowRadius();
+    deco_manager_->inactive_shadow_radius = optionGetInactiveShadowRadius();
+    deco_manager_->shadow_offset = nux::Point(optionGetShadowXOffset(), optionGetShadowYOffset());
+  }
+  else
+  {
+    auto const& style = decoration::Style::Get();
+    deco_manager_->shadow_offset = style->ShadowOffset();
+    deco_manager_->active_shadow_color = style->ActiveShadowColor();
+    deco_manager_->active_shadow_radius = style->ActiveShadowRadius();
+    deco_manager_->inactive_shadow_color = style->InactiveShadowColor();
+    deco_manager_->inactive_shadow_radius = style->InactiveShadowRadius();
+  }
 }
 
 void UnityScreen::DamageBlurUpdateRegion(nux::Geometry const& blur_update)
@@ -863,7 +888,7 @@
   cScreen->damageRegion(CompRegionFromNuxGeo(blur_update));
 }
 
-void UnityScreen::paintDisplay()
+void UnityScreen::paintOutput()
 {
   CompOutput *output = last_output_;
 
@@ -1471,6 +1496,13 @@
                                 CompOutput* output,
                                 unsigned int mask)
 {
+  if (G_UNLIKELY(lockscreen_controller_->IsPaintInhibited()))
+  {
+    CHECKGL(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
+    CHECKGL(glClear(GL_COLOR_BUFFER_BIT));
+    return true;
+  }
+
   bool ret;
 
   /*
@@ -1504,7 +1536,7 @@
     doShellRepaint = false;
 
   if (doShellRepaint)
-    paintDisplay();
+    paintOutput();
 
   return ret;
 }
@@ -1667,6 +1699,11 @@
 
 void UnityScreen::donePaint()
 {
+  if (G_UNLIKELY(lockscreen_controller_->IsPaintInhibited()))
+  {
+    lockscreen_controller_->MarkBufferHasCleared();
+  }
+
   /*
    * It's only safe to clear the draw list if drawing actually occurred
    * (i.e. the shell was not obscured behind a fullscreen window).
@@ -2042,13 +2079,6 @@
     case MapRequest:
       ShowdesktopHandler::InhibitLeaveShowdesktopMode (event->xmaprequest.window);
       break;
-    case PropertyNotify:
-      if (bghash_ && event->xproperty.window == GDK_ROOT_WINDOW() &&
-          event->xproperty.atom == bghash_->ColorAtomId())
-      {
-        bghash_->RefreshColor();
-      }
-      break;
     default:
         if (screen->shapeEvent() + ShapeNotify == event->type)
         {
@@ -3104,18 +3134,18 @@
 
   if (uScreen->doShellRepaint && window == uScreen->onboard_)
   {
-    uScreen->paintDisplay();
+    uScreen->paintOutput();
   }
   else if (uScreen->doShellRepaint &&
            window == uScreen->firstWindowAboveShell &&
            !uScreen->forcePaintOnTop() &&
            !uScreen->fullscreenRegion.contains(window->geometry()))
   {
-    uScreen->paintDisplay();
+    uScreen->paintOutput();
   }
   else if (locked && CanBypassLockScreen())
   {
-    uScreen->paintDisplay();
+    uScreen->paintOutput();
   }
 
   enum class DrawPanelShadow
@@ -3598,43 +3628,16 @@
       break;
     }
     case UnityshellOptions::OverrideDecorationTheme:
-      if (optionGetOverrideDecorationTheme())
-      {
-        deco_manager_->active_shadow_color = NuxColorFromCompizColor(optionGetActiveShadowColor());
-        deco_manager_->inactive_shadow_color = NuxColorFromCompizColor(optionGetInactiveShadowColor());
-        deco_manager_->active_shadow_radius = optionGetActiveShadowRadius();
-        deco_manager_->inactive_shadow_radius = optionGetInactiveShadowRadius();
-        deco_manager_->shadow_offset = nux::Point(optionGetShadowXOffset(), optionGetShadowYOffset());
-      }
-      else
-      {
-        OnDecorationStyleChanged();
-      }
-      break;
     case UnityshellOptions::ActiveShadowColor:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->active_shadow_color = NuxColorFromCompizColor(optionGetActiveShadowColor());
-      break;
+    case UnityshellOptions::ActiveShadowRadius:
     case UnityshellOptions::InactiveShadowColor:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->inactive_shadow_color = NuxColorFromCompizColor(optionGetInactiveShadowColor());
-      break;
-    case UnityshellOptions::ActiveShadowRadius:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->active_shadow_radius = optionGetActiveShadowRadius();
-      break;
     case UnityshellOptions::InactiveShadowRadius:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->inactive_shadow_radius = optionGetInactiveShadowRadius();
-      break;
     case UnityshellOptions::ShadowXOffset:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->shadow_offset = nux::Point(optionGetShadowXOffset(), optionGetShadowYOffset());
-      break;
     case UnityshellOptions::ShadowYOffset:
-      if (optionGetOverrideDecorationTheme())
-        deco_manager_->shadow_offset = nux::Point(optionGetShadowXOffset(), optionGetShadowYOffset());
+    {
+      UpdateDecorationStyle();
       break;
+    }
     case UnityshellOptions::LauncherHideMode:
     {
       launcher_options->hide_mode = (launcher::LauncherHideMode) optionGetLauncherHideMode();
@@ -3736,14 +3739,6 @@
     case UnityshellOptions::ShortcutOverlay:
       shortcut_controller_->SetEnabled(optionGetShortcutOverlay());
       break;
-    case UnityshellOptions::LowGraphicsMode:
-      if (optionGetLowGraphicsMode())
-          BackgroundEffectHelper::blur_type = BLUR_NONE;
-      else
-          BackgroundEffectHelper::blur_type = (unity::BlurType)optionGetDashBlurExperimental();
-
-      unity::Settings::Instance().low_gfx = optionGetLowGraphicsMode();
-      break;
     case UnityshellOptions::DecayRate:
       launcher_options->edge_decay_rate = optionGetDecayRate() * 100;
       break;
@@ -3843,6 +3838,12 @@
   ScheduleRelayout(500);
 }
 
+void UnityScreen::averageColorChangeNotify(const unsigned short *color)
+{
+  bghash_->UpdateColor(color, nux::animation::Animation::State::Running);
+  screen->averageColorChangeNotify (color);
+}
+
 bool UnityScreen::layoutSlotsAndAssignWindows()
 {
   auto const& scaled_windows = sScreen->getWindows();
@@ -3855,7 +3856,7 @@
 
     for (ScaleWindow *sw : scaled_windows)
     {
-      if (sw->window->outputDevice() == static_cast<int>(output.id()))
+      if (sw->window && sw->window->outputDevice() == static_cast<int>(output.id()))
       {
         UnityWindow::get(sw->window)->deco_win_->scaled = true;
         layout_windows.emplace_back(std::make_shared<LayoutWindow>(sw->window->id()));
@@ -3983,6 +3984,8 @@
 
   // We disable the edge barriers, to avoid blocking the mouse pointer during lockscreen
   edge_barriers_->force_disable = true;
+
+  UpdateGesturesSupport();
 }
 
 void UnityScreen::OnScreenUnlocked()
@@ -3999,19 +4002,36 @@
     screen->addAction(&action);
 
   edge_barriers_->force_disable = false;
+
+  UpdateGesturesSupport();
+}
+
+std::string UnityScreen::GetLockStampFile() const
+{
+  std::string cache_dir;
+
+  if (session_->AutomaticLogin())
+    cache_dir = DesktopUtilities::GetUserCacheDirectory();
+  else
+    cache_dir = DesktopUtilities::GetUserRuntimeDirectory();
+
+  if (cache_dir.empty())
+    return std::string();
+
+  return cache_dir+local::LOCKED_STAMP;
 }
 
 void UnityScreen::SaveLockStamp(bool save)
 {
-  auto const& cache_dir = DesktopUtilities::GetUserRuntimeDirectory();
+  std::string file_path = GetLockStampFile();
 
-  if (cache_dir.empty())
+  if (file_path.empty())
     return;
 
   if (save)
   {
     glib::Error error;
-    g_file_set_contents((cache_dir+local::LOCKED_STAMP).c_str(), "", 0, &error);
+    g_file_set_contents(file_path.c_str(), "", 0, &error);
 
     if (error)
     {
@@ -4020,7 +4040,7 @@
   }
   else
   {
-    if (g_unlink((cache_dir+local::LOCKED_STAMP).c_str()) < 0)
+    if (g_unlink(file_path.c_str()) < 0)