Merge lp:~3v1n0/unity/lowgfx-profile-setter into lp:unity

[Marco Trevisan (Treviño)]

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

[lp:~3v1n0/unity/lowgfx-profile-setter]

4243. By Marco Trevisan (Treviño) on 2017-04-04

Merging with trunk

4244. By Marco Trevisan (Treviño) on 2017-04-04

debian/unity.install: include compiz-config-profile-setter

4245. By Marco Trevisan (Treviño) on 2017-04-05

Merging with hikiko's parent branch

4246. By Marco Trevisan (Treviño) on 2017-04-05

test_thumbnail_generator: increase the wait time for multiple checks

4247. By Marco Trevisan (Treviño) on 2017-04-25

compiz_config_profile_setter: use plain strings for upstart dbus infos

As we don't build-depend on libupstart-dev anymore

Unmerged revisions

=== modified file 'data/com.canonical.Unity.gschema.xml'
--- data/com.canonical.Unity.gschema.xml	2017-01-25 16:40:35 +0000
+++ data/com.canonical.Unity.gschema.xml	2017-04-04 10:15:47 +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">

=== modified file 'decorations/DecorationsWindowButton.cpp'
--- decorations/DecorationsWindowButton.cpp	2016-08-04 08:53:20 +0000
+++ decorations/DecorationsWindowButton.cpp	2017-04-04 10:15:47 +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 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2017-02-27 13:47:32 +0000
+++ plugins/unityshell/src/unityshell.cpp	2017-04-04 10:15:47 +0000
@@ -292,23 +292,28 @@
     }
   }
 
-    //In case of software rendering then enable lowgfx mode.
+  //In case of software rendering then enable lowgfx 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;
-    }
+      (getenv("UNITY_LOW_GFX_MODE") != NULL && atoi(getenv("UNITY_LOW_GFX_MODE")) == 1))
+  {
+    unity_settings_.low_gfx = true;
+  }
 
   if (getenv("UNITY_LOW_GFX_MODE") != NULL && atoi(getenv("UNITY_LOW_GFX_MODE")) == 0)
   {
     unity_settings_.low_gfx = false;
   }
+
+  if (unity_settings_.low_gfx())
+    BackgroundEffectHelper::blur_type = BLUR_NONE;
+
+  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)
@@ -384,7 +389,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));
@@ -3751,14 +3755,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;

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2016-07-18 17:20:07 +0000
+++ plugins/unityshell/unityshell.xml.in	2017-04-04 10:15:47 +0000
@@ -160,12 +160,6 @@
                   <_long>Enables possibility to display an overlay showing available mouse and keyboard shortcuts.</_long>
                   <default>true</default>
                 </option>
-
-                <option name="low_graphics_mode"  type="bool">
-                  <_short>Enable Low Graphics Mode</_short>
-                  <_long>Enables low graphics mode regardless of hardware in the system</_long>
-                  <default>false</default>
-                </option>
             </group>
 
             <group>

=== modified file 'tools/CMakeLists.txt'
--- tools/CMakeLists.txt	2016-09-05 10:46:49 +0000
+++ tools/CMakeLists.txt	2017-04-04 10:15:47 +0000
@@ -19,6 +19,7 @@
 
 string (REPLACE ";" " " CFLAGS "${CFLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CFLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CFLAGS}")
 
 set(LIBS ${UAPSC_DEPS_LIBRARIES})
 
@@ -29,6 +30,10 @@
 target_link_libraries(unity-active-plugins-safety-check ${LIBS})
 install(TARGETS unity-active-plugins-safety-check DESTINATION ${UNITY_INSTALL_LIBDIR})
 
+add_executable(compiz-config-profile-setter compiz_config_profile_setter.c)
+target_link_libraries(compiz-config-profile-setter ${LIBS})
+install(TARGETS compiz-config-profile-setter DESTINATION ${UNITY_INSTALL_LIBDIR})
+
 configure_file (${CMAKE_CURRENT_SOURCE_DIR}/compiz-profile-selector.in ${CMAKE_CURRENT_BINARY_DIR}/compiz-profile-selector @ONLY)
 install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/compiz-profile-selector DESTINATION ${UNITY_INSTALL_LIBDIR})
 

=== modified file 'tools/compiz-profile-selector.in'
--- tools/compiz-profile-selector.in	2016-09-05 10:46:49 +0000
+++ tools/compiz-profile-selector.in	2017-04-04 10:15:47 +0000
@@ -1,13 +1,29 @@
 #!/bin/bash
-
 set -e
+
+config_dir="$XDG_CONFIG_HOME"
+if [ -z "$config_dir" ]; then
+  config_dir="$HOME/.config"
+fi
+
+default_ini="$config_dir/compiz-1/compizconfig/Default.ini"
+
+if [ -f "$default_ini" ]; then
+  rm "$default_ini"
+fi
+
 compiz_profile="ubuntu"
+settings_profile="unity"
 
 if ! /usr/lib/nux/unity_support_test -p; then
-  compiz_profile="ubuntu-lowgfx"
-fi
-
-echo "Using compiz profile '$compiz_profile'"
+  settings_profile="unity-lowgfx"
+fi
+
+if [ "$(gsettings get com.canonical.Unity lowgfx)" == "true" ]; then
+  settings_profile="unity-lowgfx"
+fi
+
+echo "Using compiz profile '$compiz_profile:$settings_profile'"
 
 if [ -n "$UPSTART_SESSION" ]; then
   initctl set-env -g COMPIZ_CONFIG_PROFILE="$compiz_profile"
@@ -16,4 +32,6 @@
 dbus-update-activation-environment --verbose --systemd COMPIZ_CONFIG_PROFILE="$compiz_profile"
 
 export COMPIZ_CONFIG_PROFILE="$compiz_profile"
-exec @UNITY_LIBDIR@/unity-active-plugins-safety-check
+
+@UNITY_LIBDIR@/compiz-config-profile-setter $settings_profile
+@UNITY_LIBDIR@/unity-active-plugins-safety-check

=== added file 'tools/compiz_config_profile_setter.c'
--- tools/compiz_config_profile_setter.c	1970-01-01 00:00:00 +0000
+++ tools/compiz_config_profile_setter.c	2017-04-04 10:15:47 +0000
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan <[e-mail]>
+ */
+
+#include <ccs.h>
+#include <gio/gio.h>
+#include <upstart/upstart-dbus.h>
+
+#define COMPIZ_CONFIG_PROFILE_ENV "COMPIZ_CONFIG_PROFILE"
+#define COMPIZ_CONFIG_DEFAULT_PROFILE "ubuntu"
+
+extern const CCSInterfaceTable ccsDefaultInterfaceTable;
+
+static gchar *
+get_ccs_profile_env_from_env_list (const gchar **env_vars)
+{
+  gchar *var = NULL;
+
+  for (; env_vars && *env_vars; ++env_vars)
+    {
+      if (g_str_has_prefix (*env_vars, COMPIZ_CONFIG_PROFILE_ENV "="))
+        {
+          var = g_strdup (*env_vars + G_N_ELEMENTS (COMPIZ_CONFIG_PROFILE_ENV));
+          break;
+        }
+    }
+
+  return var;
+}
+
+static gchar *
+get_ccs_profile_env_from_session_manager ()
+{
+  GDBusConnection *bus;
+  GVariant *environment_prop, *environment_prop_list;
+  const gchar **env_vars;
+  gchar *profile;
+
+  profile = NULL;
+  bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
+
+  environment_prop = g_dbus_connection_call_sync (bus,
+                                                  "org.freedesktop.systemd1",
+                                                  "/org/freedesktop/systemd1",
+                                                  "org.freedesktop.DBus.Properties",
+                                                  "Get",
+                                                  g_variant_new ("(ss)",
+                                                                  "org.freedesktop.systemd1.Manager",
+                                                                  "Environment"),
+                                                  G_VARIANT_TYPE ("(v)"),
+                                                  G_DBUS_CALL_FLAGS_NONE,
+                                                  -1,
+                                                  NULL,
+                                                  NULL);
+
+  if (!environment_prop)
+    goto out;
+
+  g_variant_get (environment_prop, "(v)", &environment_prop_list, NULL);
+  env_vars = g_variant_get_strv (environment_prop_list, NULL);
+  profile = get_ccs_profile_env_from_env_list (env_vars);
+
+  g_clear_pointer (&environment_prop, g_variant_unref);
+  g_clear_pointer (&environment_prop_list, g_variant_unref);
+
+  if (!profile && g_getenv ("UPSTART_SESSION"))
+    {
+      const gchar * const * empty_array[] = {0};
+      environment_prop_list = g_dbus_connection_call_sync (bus,
+                                                           DBUS_SERVICE_UPSTART,
+                                                           DBUS_PATH_UPSTART,
+                                                           DBUS_INTERFACE_UPSTART,
+                                                           "ListEnv",
+                                                           g_variant_new("(@as)",
+                                                             g_variant_new_strv (NULL, 0)),
+                                                           NULL,
+                                                           G_DBUS_CALL_FLAGS_NONE,
+                                                           -1,
+                                                           NULL,
+                                                           NULL);
+      if (!environment_prop_list)
+        goto out;
+
+      g_variant_get (environment_prop_list, "(^a&s)", &env_vars);
+      profile = get_ccs_profile_env_from_env_list (env_vars);
+
+      g_variant_unref (environment_prop_list);
+    }
+
+out:
+  g_object_unref (bus);
+
+  return profile;
+}
+
+static gboolean
+is_compiz_profile_available (const gchar *profile)
+{
+  gboolean is_available;
+  gchar *profile_path;
+
+  profile_path = g_strdup_printf ("%s/compiz-1/compizconfig/%s.ini",
+                                  g_get_user_config_dir (), profile);
+  is_available = g_file_test (profile_path, G_FILE_TEST_EXISTS);
+  g_free (profile_path);
+
+  if (!is_available)
+    {
+      profile_path = g_strdup_printf ("/etc/compizconfig/%s.ini", profile);
+      is_available = g_file_test (profile_path, G_FILE_TEST_EXISTS);
+      g_free (profile_path);
+    }
+
+  return is_available;
+}
+
+static gboolean
+set_compiz_profile (CCSContext *ccs_context, const gchar *profile_name)
+{
+  CCSPluginList plugins;
+  const char *ccs_backend;
+
+  ccs_backend = ccsGetBackend (ccs_context);
+
+  ccsSetProfile (ccs_context, profile_name);
+  ccsReadSettings (ccs_context);
+  ccsWriteSettings (ccs_context);
+
+  if (g_strcmp0 (ccs_backend, "gsettings") == 0)
+    g_settings_sync ();
+
+  plugins = ccsContextGetPlugins (ccs_context);
+
+  for (CCSPluginList p = plugins; p; p = p->next)
+    {
+      CCSPlugin* plugin = p->data;
+      ccsReadPluginSettings (plugin);
+    }
+
+  return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
+  CCSContext *context;
+  const gchar *profile, *current_profile, *ccs_profile_env;
+  gchar *session_manager_ccs_profile;
+
+  if (argc < 2)
+    {
+      g_warning ("You need to pass a valid profile as argument\n");
+      return 1;
+    }
+
+  session_manager_ccs_profile = get_ccs_profile_env_from_session_manager ();
+
+  if (session_manager_ccs_profile)
+    {
+      g_setenv (COMPIZ_CONFIG_PROFILE_ENV, session_manager_ccs_profile, TRUE);
+      g_clear_pointer (&session_manager_ccs_profile, g_free);
+    }
+  else
+    {
+      ccs_profile_env = g_getenv (COMPIZ_CONFIG_PROFILE_ENV);
+
+      if (!ccs_profile_env || ccs_profile_env[0] == '\0')
+        {
+          g_setenv (COMPIZ_CONFIG_PROFILE_ENV, COMPIZ_CONFIG_DEFAULT_PROFILE, TRUE);
+        }
+    }
+
+  profile = argv[1];
+
+  if (!is_compiz_profile_available (profile))
+    {
+      g_warning ("Compiz profile '%s' not found", profile);
+      return 1;
+    }
+
+  context = ccsContextNew (0, &ccsDefaultInterfaceTable);
+
+  if (!context)
+    {
+      g_warning ("Impossible to get Compiz config context\n");
+      return -1;
+    }
+
+  g_debug ("Setting profile to '%s' (for environment '%s')",
+           profile, g_getenv (COMPIZ_CONFIG_PROFILE_ENV));
+
+  current_profile = ccsGetProfile (context);
+
+  if (g_strcmp0 (current_profile, profile) == 0)
+    {
+      g_print("We're already using profile '%s', no need to switch\n", profile);
+      return 0;
+    }
+
+  if (!set_compiz_profile (context, profile))
+    {
+      ccsFreeContext (context);
+      return 1;
+    }
+
+  ccsFreeContext (context);
+
+  g_print ("Switched to profile '%s' (for environment '%s')\n",
+           profile, g_getenv (COMPIZ_CONFIG_PROFILE_ENV));
+
+  /* This is for printing debug informations */
+  context = ccsContextNew (0, &ccsDefaultInterfaceTable);
+  ccsFreeContext (context);
+
+  return 0;
+}

=== modified file 'tools/unity.cmake'
--- tools/unity.cmake	2016-09-01 18:55:15 +0000
+++ tools/unity.cmake	2017-04-04 10:15:47 +0000
@@ -58,13 +58,26 @@
 def set_unity_env ():
     '''set variable environnement for unity to run'''
 
+    compiz_config_profile = 'unity'
     os.environ['COMPIZ_CONFIG_PROFILE'] = 'ubuntu'
 
     try:
-      if subprocess.call('/usr/lib/nux/unity_support_test -f'.split()) > 0:
-        os.environ['COMPIZ_CONFIG_PROFILE'] = 'ubuntu-lowgfx'
-    except:
-      pass
+        if subprocess.call('/usr/lib/nux/unity_support_test -f'.split()) > 0:
+            compiz_config_profile += '-lowgfx'
+    except:
+        pass
+
+    try:
+        if subprocess.check_output('gsettings get com.canonical.Unity lowgfx'.split()) == b'true\n':
+            compiz_config_profile += '-lowgfx'
+    except:
+        pass
+
+    try:
+        subprocess.call('@UNITY_LIBDIR@/compiz-config-profile-setter {}'.format(
+            compiz_config_profile).split())
+    except:
+        pass
 
     if not 'DISPLAY' in os.environ:
         # take an optimistic chance and warn about it :)

=== modified file 'unity-shared/BackgroundEffectHelper.cpp'
--- unity-shared/BackgroundEffectHelper.cpp	2016-12-12 08:27:16 +0000
+++ unity-shared/BackgroundEffectHelper.cpp	2017-04-04 10:15:47 +0000
@@ -21,7 +21,6 @@
 #include "BackgroundEffectHelper.h"
 
 #include "TextureCache.h"
-#include "UnitySettings.h"
 
 namespace
 {
@@ -50,9 +49,6 @@
   owner.changed.connect(sigc::mem_fun(this, &BackgroundEffectHelper::OnOwnerChanged));
   TextureCache::GetDefault().themed_invalidated.connect(sigc::mem_fun(this, &BackgroundEffectHelper::LoadTextures));
   LoadTextures();
-
-  if (Settings::Instance().low_gfx())
-    blur_type = BLUR_NONE;
 }
 
 BackgroundEffectHelper::BackgroundEffectHelper()

=== modified file 'unity-shared/UnitySettings.cpp'
--- unity-shared/UnitySettings.cpp	2016-12-20 16:32:03 +0000
+++ unity-shared/UnitySettings.cpp	2017-04-04 10:15:47 +0000
@@ -18,6 +18,8 @@
 *              Andrea Azzarone <[e-mail]>
 */
 
+#include "config.h"
+
 #include <glib.h>
 #include <NuxCore/Logger.h>
 #include <UnityCore/GLibSource.h>
@@ -40,6 +42,7 @@
 const std::string DOUBLE_CLICK_ACTIVATE = "double-click-activate";
 const std::string DESKTOP_TYPE = "desktop-type";
 const std::string PAM_CHECK_ACCOUNT_TYPE = "pam-check-account-type";
+const std::string LOWGFX = "lowgfx";
 
 const std::string LAUNCHER_SETTINGS = "com.canonical.Unity.Launcher";
 const std::string LAUNCHER_POSITION = "launcher-position";
@@ -72,6 +75,10 @@
 const std::string DASH_TAP = "dash-tap";
 const std::string WINDOWS_DRAG_PINCH = "windows-drag-pinch";
 
+const std::string CCS_PROFILE_CHANGER_TOOL = "compiz-config-profile-setter";
+const std::string CCS_PROFILE_DEFAULT = "unity";
+const std::string CCS_PROFILE_LOWGFX = CCS_PROFILE_DEFAULT + "-lowgfx";
+
 const int DEFAULT_LAUNCHER_SIZE = 64;
 const int MINIMUM_DESKTOP_HEIGHT = 800;
 const int GNOME_SETTINGS_CHANGED_WAIT_SECONDS = 1;
@@ -112,10 +119,15 @@
     parent_->launcher_position.SetSetterFunction(sigc::mem_fun(this, &Impl::SetLauncherPosition));
     parent_->desktop_type.SetGetterFunction(sigc::mem_fun(this, &Impl::GetDesktopType));
     parent_->pam_check_account_type.SetGetterFunction(sigc::mem_fun(this, &Impl::GetPamCheckAccountType));
+    parent_->low_gfx.changed.connect(sigc::mem_fun(this, &Impl::UpdateCompizProfile));
 
     for (unsigned i = 0; i < monitors::MAX; ++i)
       em_converters_.emplace_back(std::make_shared<EMConverter>());
 
+    signals_.Add<void, GSettings*, const gchar*>(usettings_, "changed::" + LOWGFX, [this] (GSettings*, const gchar *) {
+      UpdateLowGfx();
+    });
+
     signals_.Add<void, GSettings*, const gchar*>(usettings_, "changed::" + FORM_FACTOR, [this] (GSettings*, const gchar*) {
       CacheFormFactor();
     });
@@ -179,8 +191,11 @@
 
     UScreen::GetDefault()->changed.connect(sigc::hide(sigc::hide(sigc::mem_fun(this, &Impl::UpdateDPI))));
 
+    UpdateLowGfx();
+    UpdateCompizProfile(parent_->low_gfx());
+    UpdateLimSetting();
+
     // The order is important here, DPI is the last thing to be updated
-    UpdateLimSetting();
     UpdateGesturesSetting();
     UpdateTextScaleFactor();
     UpdateCursorScaleFactor();
@@ -229,6 +244,25 @@
     cached_launcher_position_ = static_cast<LauncherPosition>(g_settings_get_enum(launcher_settings_, LAUNCHER_POSITION.c_str()));
   }
 
+  void UpdateLowGfx()
+  {
+    parent_->low_gfx = g_settings_get_boolean(usettings_, LOWGFX.c_str()) != FALSE;
+  }
+
+  void UpdateCompizProfile(bool lowgfx)
+  {
+    auto const& profile = lowgfx ? CCS_PROFILE_LOWGFX : CCS_PROFILE_DEFAULT;
+    auto profile_change_cmd = (std::string(UNITY_LIBDIR G_DIR_SEPARATOR_S) + CCS_PROFILE_CHANGER_TOOL + " " + profile);
+
+    glib::Error error;
+    g_spawn_command_line_async(profile_change_cmd.c_str(), &error);
+
+    if (error)
+    {
+      LOG_ERROR(logger) << "Failed to switch compiz profile: " << error;
+    }
+  }
+
   void UpdateLimSetting()
   {
     parent_->lim_movement_thresold = g_settings_get_uint(lim_settings_, CLICK_MOVEMENT_THRESHOLD.c_str());
@@ -329,7 +363,7 @@
     auto const& geo = uscreen->GetMonitorGeometry(monitor);
     auto const& size = uscreen->GetMonitorPhysicalSize(monitor);
     auto scale = DPI_SCALING_STEP;
-      
+
     if ((size.width == 160 && size.height == 90) ||
         (size.width == 160 && size.height == 100) ||
         (size.width == 16 && size.height == 9) ||
@@ -340,7 +374,7 @@
 
     if (size.width > 0 && size.height > 0)
     {
-      const double dpi_x = static_cast<double>(geo.width) / (size.width / 25.4);  
+      const double dpi_x = static_cast<double>(geo.width) / (size.width / 25.4);
       const double dpi_y = static_cast<double>(geo.height) / (size.height / 25.4);
 
       const auto dpi = std::max(dpi_x, dpi_y);
@@ -481,8 +515,7 @@
 //
 
 Settings::Settings()
-  : low_gfx(false)
-  , is_standalone(false)
+  : is_standalone(false)
   , pimpl(new Impl(this))
 {
   if (settings_instance)

=== modified file 'unity-shared/UnitySettings.h'
--- unity-shared/UnitySettings.h	2016-07-04 14:21:00 +0000
+++ unity-shared/UnitySettings.h	2017-04-04 10:15:47 +0000
@@ -76,7 +76,6 @@
   nux::Property<bool> gestures_windows_drag_pinch;
 
   sigc::signal<void> dpi_changed;
-  sigc::signal<void> low_gfx_changed;
   sigc::signal<void> gestures_changed;
 
 private: