Fix indentation

5 files changed, 2076 insertions, 2096 deletions

diff --git a/settings/xfpm-settings-app.c b/settings/xfpm-settings-app.c
index f1b4fa45..872b6c38 100644
--- a/settings/xfpm-settings-app.c
+++ b/settings/xfpm-settings-app.c
@@ -40,9 +40,9 @@
 
 struct _XfpmSettingsAppPrivate
 {
-    gboolean          debug;
-    Window            socket_id;
-    gchar            *device_id;
+  gboolean          debug;
+  Window            socket_id;
+  gchar            *device_id;
 };
 
 static void xfpm_settings_app_launch     (GApplication *app);
@@ -70,202 +70,202 @@ G_DEFINE_TYPE_WITH_PRIVATE(XfpmSettingsApp, xfpm_settings_app, GTK_TYPE_APPLICAT
 static void
 xfpm_settings_app_init (XfpmSettingsApp *app)
 {
-    const GOptionEntry option_entries[] = {
-      { "socket-id", 's', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_INT,    NULL, N_("Settings manager socket"), N_("SOCKET ID") },
-      { "device-id", 'd', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_STRING, NULL, N_("Display a specific device by UpDevice object path"), N_("UpDevice object path") },
-      { "debug",    '\0', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Enable debugging"), NULL },
-      { "version",   'V', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Display version information"), NULL },
-      { "quit",      'q', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Cause xfce4-power-manager-settings to quit"), NULL },
-      { NULL, },
-    };
-
-    g_application_add_main_option_entries (G_APPLICATION (app), option_entries);
+  const GOptionEntry option_entries[] = {
+    { "socket-id", 's', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_INT,    NULL, N_("Settings manager socket"), N_("SOCKET ID") },
+    { "device-id", 'd', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_STRING, NULL, N_("Display a specific device by UpDevice object path"), N_("UpDevice object path") },
+    { "debug",    '\0', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Enable debugging"), NULL },
+    { "version",   'V', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Display version information"), NULL },
+    { "quit",      'q', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE,   NULL, N_("Cause xfce4-power-manager-settings to quit"), NULL },
+    { NULL, },
+  };
+
+  g_application_add_main_option_entries (G_APPLICATION (app), option_entries);
 }
 
 static void
 xfpm_settings_app_startup (GApplication *app)
 {
-    const GActionEntry action_entries[] = {
-      { "socket-id", activate_socket, "i"  },
-      { "device-id", activate_device, "s"  },
-      { "debug",     activate_debug,  NULL },
-      { "activate",  activate_window, NULL },
-      { "quit",      activate_quit,   NULL },
-    };
-
-    TRACE ("entering");
-
-    g_action_map_add_action_entries (G_ACTION_MAP (app),
-                                     action_entries,
-                                     G_N_ELEMENTS (action_entries),
-                                     app);
-
-    /* keep the app running until we've launched our window */
-    g_application_hold (app);
-
-    /* let the parent class do it's startup as well */
-    G_APPLICATION_CLASS(xfpm_settings_app_parent_class)->startup(app);
+  const GActionEntry action_entries[] = {
+    { "socket-id", activate_socket, "i"  },
+    { "device-id", activate_device, "s"  },
+    { "debug",     activate_debug,  NULL },
+    { "activate",  activate_window, NULL },
+    { "quit",      activate_quit,   NULL },
+  };
+
+  TRACE ("entering");
+
+  g_action_map_add_action_entries (G_ACTION_MAP (app),
+                                   action_entries,
+                                   G_N_ELEMENTS (action_entries),
+                                   app);
+
+  /* keep the app running until we've launched our window */
+  g_application_hold (app);
+
+  /* let the parent class do it's startup as well */
+  G_APPLICATION_CLASS(xfpm_settings_app_parent_class)->startup(app);
 }
 
 static void
 xfpm_settings_app_activate (GApplication *app)
 {
-    TRACE ("entering");
+  TRACE ("entering");
 }
 
 static void
 xfpm_settings_app_launch (GApplication *app)
 {
-    XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (XFPM_SETTINGS_APP (app));
-
-    XfpmPowerManager *manager;
-    XfconfChannel    *channel;
-    GError           *error = NULL;
-    GtkWidget        *dialog;
-    GHashTable       *hash;
-    GVariant         *config;
-    GVariantIter     *iter;
-    gchar            *key, *value;
-    GList            *windows;
-
-    gboolean has_battery;
-    gboolean auth_suspend;
-    gboolean auth_hibernate;
-    gboolean can_suspend;
-    gboolean can_hibernate;
-    gboolean can_shutdown;
-    gboolean has_lcd_brightness;
-    gboolean has_sleep_button;
-    gboolean has_hibernate_button;
-    gboolean has_power_button;
-    gboolean has_battery_button;
-    gboolean has_lid;
-    gint     start_xfpm_if_not_running;
-
-    TRACE ("entering");
-
-    windows = gtk_application_get_windows (GTK_APPLICATION (app));
-
-    if (windows != NULL)
+  XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (XFPM_SETTINGS_APP (app));
+
+  XfpmPowerManager *manager;
+  XfconfChannel    *channel;
+  GError           *error = NULL;
+  GtkWidget        *dialog;
+  GHashTable       *hash;
+  GVariant         *config;
+  GVariantIter     *iter;
+  gchar            *key, *value;
+  GList            *windows;
+
+  gboolean has_battery;
+  gboolean auth_suspend;
+  gboolean auth_hibernate;
+  gboolean can_suspend;
+  gboolean can_hibernate;
+  gboolean can_shutdown;
+  gboolean has_lcd_brightness;
+  gboolean has_sleep_button;
+  gboolean has_hibernate_button;
+  gboolean has_power_button;
+  gboolean has_battery_button;
+  gboolean has_lid;
+  gint     start_xfpm_if_not_running;
+
+  TRACE ("entering");
+
+  windows = gtk_application_get_windows (GTK_APPLICATION (app));
+
+  if (windows != NULL)
+  {
+    XFPM_DEBUG ("window already opened");
+
+    gdk_notify_startup_complete ();
+
+    if (priv->device_id != NULL)
     {
-        XFPM_DEBUG ("window already opened");
-
-        gdk_notify_startup_complete ();
-
-        if (priv->device_id != NULL)
-        {
-            xfpm_settings_show_device_id (priv->device_id);
-        }
-
-        return;
-    }
-
-    manager = xfpm_power_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
-                                                         G_BUS_NAME_OWNER_FLAGS_NONE,
-                                                         "org.xfce.PowerManager",
-                                                         "/org/xfce/PowerManager",
-                                                         NULL,
-                                                         &error);
-
-    if (error != NULL)
-    {
-        g_critical("xfpm_power_manager_proxy_new_sync failed: %s\n", error->message);
-        xfce_dialog_show_warning (NULL,
-                                 _("Xfce Power Manager"),
-                                 "%s",
-                                 _("Failed to connect to power manager"));
-        g_clear_error (&error);
-        return;
-    }
-
-
-    while ( !xfpm_power_manager_call_get_config_sync (manager, &config, NULL, NULL) )
-    {
-        GtkWidget *startw;
-
-        startw = gtk_message_dialog_new (NULL,
-                                         GTK_DIALOG_MODAL,
-                                         GTK_MESSAGE_QUESTION,
-                                         GTK_BUTTONS_YES_NO,
-                                         _("Xfce4 Power Manager is not running, do you want to launch it now?"));
-        start_xfpm_if_not_running = gtk_dialog_run (GTK_DIALOG (startw));
-        gtk_widget_destroy (startw);
-
-        if (start_xfpm_if_not_running == GTK_RESPONSE_YES)
-        {
-            GAppInfo *app_info;
-
-            app_info = g_app_info_create_from_commandline ("xfce4-power-manager", "Xfce4 Power Manager",
-                                                           G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, NULL);
-            if (!g_app_info_launch (app_info, NULL, NULL, &error)) {
-                if (error != NULL) {
-                  g_warning ("xfce4-power-manager could not be launched. %s", error->message);
-                  g_error_free (error);
-                  error = NULL;
-                }
-            }
-            /* wait 2 seconds for xfpm to startup */
-            g_usleep ( 2 * 1000000 );
-        }
-        else
-        {
-            /* exit without starting xfpm */
-            return;
-        }
+      xfpm_settings_show_device_id (priv->device_id);
     }
 
-    if ( !xfconf_init(&error) )
+    return;
+  }
+
+  manager = xfpm_power_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+                                                       G_BUS_NAME_OWNER_FLAGS_NONE,
+                                                       "org.xfce.PowerManager",
+                                                       "/org/xfce/PowerManager",
+                                                       NULL,
+                                                       &error);
+
+  if (error != NULL)
+  {
+    g_critical("xfpm_power_manager_proxy_new_sync failed: %s\n", error->message);
+    xfce_dialog_show_warning (NULL,
+                             _("Xfce Power Manager"),
+                             "%s",
+                             _("Failed to connect to power manager"));
+    g_clear_error (&error);
+    return;
+  }
+
+
+  while ( !xfpm_power_manager_call_get_config_sync (manager, &config, NULL, NULL) )
+  {
+    GtkWidget *startw;
+
+    startw = gtk_message_dialog_new (NULL,
+                                     GTK_DIALOG_MODAL,
+                                     GTK_MESSAGE_QUESTION,
+                                     GTK_BUTTONS_YES_NO,
+                                     _("Xfce4 Power Manager is not running, do you want to launch it now?"));
+    start_xfpm_if_not_running = gtk_dialog_run (GTK_DIALOG (startw));
+    gtk_widget_destroy (startw);
+
+    if (start_xfpm_if_not_running == GTK_RESPONSE_YES)
     {
-        g_critical("xfconf init failed: %s using default settings\n", error->message);
-        xfce_dialog_show_warning (NULL,
-                                  _("Xfce Power Manager"),
-                                  "%s",
-                                  _("Failed to load power manager configuration, using defaults"));
-        g_clear_error (&error);
+      GAppInfo *app_info;
+
+      app_info = g_app_info_create_from_commandline ("xfce4-power-manager", "Xfce4 Power Manager",
+                                                     G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, NULL);
+      if (!g_app_info_launch (app_info, NULL, NULL, &error)) {
+          if (error != NULL) {
+            g_warning ("xfce4-power-manager could not be launched. %s", error->message);
+            g_error_free (error);
+            error = NULL;
+          }
+      }
+      /* wait 2 seconds for xfpm to startup */
+      g_usleep ( 2 * 1000000 );
     }
-
-
-    channel = xfconf_channel_new(XFPM_CHANNEL);
-
-    xfpm_debug_init (priv->debug);
-
-    hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
-    g_variant_get (config, "a{ss}", &iter);
-    while (g_variant_iter_next (iter, "{ss}", &key, &value))
+    else
     {
-        g_hash_table_insert (hash, key, value);
+      /* exit without starting xfpm */
+      return;
     }
-    g_variant_iter_free (iter);
-    g_variant_unref (config);
-
-
-    has_battery = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-battery"));
-    has_lid = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-lid"));
-    can_suspend = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-suspend"));
-    can_hibernate = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-hibernate"));
-    auth_suspend = xfpm_string_to_bool (g_hash_table_lookup (hash, "auth-suspend"));
-    auth_hibernate = xfpm_string_to_bool (g_hash_table_lookup (hash, "auth-hibernate"));
-    has_lcd_brightness = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-brightness"));
-    has_sleep_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "sleep-button"));
-    has_power_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "power-button"));
-    has_hibernate_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "hibernate-button"));
-    has_battery_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "battery-button"));
-    can_shutdown = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-shutdown"));
-
-    DBG("socket_id %i", (int)priv->socket_id);
-    DBG("device id %s", priv->device_id);
-
-    dialog = xfpm_settings_dialog_new (channel, auth_suspend, auth_hibernate,
-                                       can_suspend, can_hibernate, can_shutdown, has_battery, has_lcd_brightness,
-                                       has_lid, has_sleep_button, has_hibernate_button, has_power_button, has_battery_button,
-                                       priv->socket_id, priv->device_id, GTK_APPLICATION (app));
-
-    g_hash_table_destroy (hash);
-
-    gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (dialog));
-    g_application_release (app);
-
-    g_object_unref (manager);
+  }
+
+  if ( !xfconf_init(&error) )
+  {
+    g_critical("xfconf init failed: %s using default settings\n", error->message);
+    xfce_dialog_show_warning (NULL,
+                              _("Xfce Power Manager"),
+                              "%s",
+                              _("Failed to load power manager configuration, using defaults"));
+    g_clear_error (&error);
+  }
+
+
+  channel = xfconf_channel_new(XFPM_CHANNEL);
+
+  xfpm_debug_init (priv->debug);
+
+  hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+  g_variant_get (config, "a{ss}", &iter);
+  while (g_variant_iter_next (iter, "{ss}", &key, &value))
+  {
+    g_hash_table_insert (hash, key, value);
+  }
+  g_variant_iter_free (iter);
+  g_variant_unref (config);
+
+
+  has_battery = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-battery"));
+  has_lid = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-lid"));
+  can_suspend = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-suspend"));
+  can_hibernate = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-hibernate"));
+  auth_suspend = xfpm_string_to_bool (g_hash_table_lookup (hash, "auth-suspend"));
+  auth_hibernate = xfpm_string_to_bool (g_hash_table_lookup (hash, "auth-hibernate"));
+  has_lcd_brightness = xfpm_string_to_bool (g_hash_table_lookup (hash, "has-brightness"));
+  has_sleep_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "sleep-button"));
+  has_power_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "power-button"));
+  has_hibernate_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "hibernate-button"));
+  has_battery_button = xfpm_string_to_bool (g_hash_table_lookup (hash, "battery-button"));
+  can_shutdown = xfpm_string_to_bool (g_hash_table_lookup (hash, "can-shutdown"));
+
+  DBG("socket_id %i", (int)priv->socket_id);
+  DBG("device id %s", priv->device_id);
+
+  dialog = xfpm_settings_dialog_new (channel, auth_suspend, auth_hibernate,
+                                     can_suspend, can_hibernate, can_shutdown, has_battery, has_lcd_brightness,
+                                     has_lid, has_sleep_button, has_hibernate_button, has_power_button, has_battery_button,
+                                     priv->socket_id, priv->device_id, GTK_APPLICATION (app));
+
+  g_hash_table_destroy (hash);
+
+  gtk_application_add_window (GTK_APPLICATION (app), GTK_WINDOW (dialog));
+  g_application_release (app);
+
+  g_object_unref (manager);
 }
 
 static void
@@ -273,14 +273,14 @@ activate_socket (GSimpleAction  *action,
                  GVariant       *parameter,
                  gpointer        data)
 {
-    XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
-    XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
+  XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
+  XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
 
-    TRACE ("entering");
+  TRACE ("entering");
 
-    priv->socket_id = g_variant_get_int32 (parameter);
+  priv->socket_id = g_variant_get_int32 (parameter);
 
-    xfpm_settings_app_launch (G_APPLICATION (app));
+  xfpm_settings_app_launch (G_APPLICATION (app));
 }
 
 static void
@@ -288,14 +288,14 @@ activate_device (GSimpleAction  *action,
                  GVariant       *parameter,
                  gpointer        data)
 {
-    XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
-    XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
+  XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
+  XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
 
-    TRACE ("entering");
+  TRACE ("entering");
 
-    priv->device_id = g_strdup(g_variant_get_string (parameter, NULL));
+  priv->device_id = g_strdup(g_variant_get_string (parameter, NULL));
 
-    xfpm_settings_app_launch (G_APPLICATION (app));
+  xfpm_settings_app_launch (G_APPLICATION (app));
 }
 
 static void
@@ -303,14 +303,14 @@ activate_debug (GSimpleAction  *action,
                 GVariant       *parameter,
                 gpointer        data)
 {
-    XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
-    XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
+  XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
+  XfpmSettingsAppPrivate *priv = xfpm_settings_app_get_instance_private (app);
 
-    TRACE ("entering");
+  TRACE ("entering");
 
-    priv->debug = TRUE;
+  priv->debug = TRUE;
 
-    xfpm_settings_app_launch (G_APPLICATION (app));
+  xfpm_settings_app_launch (G_APPLICATION (app));
 }
 
 static void
@@ -318,11 +318,11 @@ activate_window (GSimpleAction  *action,
                  GVariant       *parameter,
                  gpointer        data)
 {
-    XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
+  XfpmSettingsApp *app = XFPM_SETTINGS_APP (data);
 
-    TRACE ("entering");
+  TRACE ("entering");
 
-    xfpm_settings_app_launch (G_APPLICATION (app));
+  xfpm_settings_app_launch (G_APPLICATION (app));
 }
 
 static void
@@ -330,99 +330,99 @@ activate_quit (GSimpleAction  *action,
                GVariant       *parameter,
                gpointer        data)
 {
-    GtkApplication *app = GTK_APPLICATION (data);
-    GList *windows;
+  GtkApplication *app = GTK_APPLICATION (data);
+  GList *windows;
 
-    TRACE ("entering");
+  TRACE ("entering");
 
-    windows = gtk_application_get_windows (app);
+  windows = gtk_application_get_windows (app);
 
-    if (windows)
-    {
-        /* Remove our window if we've attahced one */
-        gtk_application_remove_window (app, GTK_WINDOW (windows->data));
-    }
+  if (windows)
+  {
+    /* Remove our window if we've attached one */
+    gtk_application_remove_window (app, GTK_WINDOW (windows->data));
+  }
 }
 
 static gboolean
 xfpm_settings_app_local_options (GApplication *g_application,
                                  GVariantDict *options)
 {
-    TRACE ("entering");
+  TRACE ("entering");
+
+  /* --version */
+  if (g_variant_dict_contains (options, "version"))
+  {
+    g_print(_("This is %s version %s, running on Xfce %s.\n"), PACKAGE,
+            VERSION, xfce_version_string());
+    g_print(_("Built with GTK+ %d.%d.%d, linked with GTK+ %d.%d.%d."),
+            GTK_MAJOR_VERSION,GTK_MINOR_VERSION, GTK_MICRO_VERSION,
+            gtk_major_version, gtk_minor_version, gtk_micro_version);
+    g_print("\n");
 
-    /* --version */
-    if (g_variant_dict_contains (options, "version"))
-    {
-        g_print(_("This is %s version %s, running on Xfce %s.\n"), PACKAGE,
-                VERSION, xfce_version_string());
-        g_print(_("Built with GTK+ %d.%d.%d, linked with GTK+ %d.%d.%d."),
-                GTK_MAJOR_VERSION,GTK_MINOR_VERSION, GTK_MICRO_VERSION,
-                gtk_major_version, gtk_minor_version, gtk_micro_version);
-        g_print("\n");
-
-        return 0;
-    }
+    return 0;
+  }
 
-    /* This will call xfpm_settings_app_startup if it needs to */
-    g_application_register (g_application, NULL, NULL);
+  /* This will call xfpm_settings_app_startup if it needs to */
+  g_application_register (g_application, NULL, NULL);
 
-    /* --debug */
-    if (g_variant_dict_contains (options, "debug"))
-    {
-        g_action_group_activate_action(G_ACTION_GROUP(g_application), "debug", NULL);
-        return 0;
-    }
+  /* --debug */
+  if (g_variant_dict_contains (options, "debug"))
+  {
+    g_action_group_activate_action(G_ACTION_GROUP(g_application), "debug", NULL);
+    return 0;
+  }
 
-    /* --socket-id */
-    if (g_variant_dict_contains (options, "socket-id") || g_variant_dict_contains (options, "s"))
-    {
-        GVariant *var;
+  /* --socket-id */
+  if (g_variant_dict_contains (options, "socket-id") || g_variant_dict_contains (options, "s"))
+  {
+    GVariant *var;
 
-        var = g_variant_dict_lookup_value (options, "socket-id", G_VARIANT_TYPE_INT32);
+    var = g_variant_dict_lookup_value (options, "socket-id", G_VARIANT_TYPE_INT32);
 
-        g_action_group_activate_action(G_ACTION_GROUP(g_application), "socket-id", var);
-        return 0;
-    }
+    g_action_group_activate_action(G_ACTION_GROUP(g_application), "socket-id", var);
+    return 0;
+  }
 
-    /* --device-id */
-    if (g_variant_dict_contains (options, "device-id") || g_variant_dict_contains (options, "d"))
-    {
-        GVariant *var;
+  /* --device-id */
+  if (g_variant_dict_contains (options, "device-id") || g_variant_dict_contains (options, "d"))
+  {
+    GVariant *var;
 
-        var = g_variant_dict_lookup_value (options, "device-id", G_VARIANT_TYPE_STRING);
+    var = g_variant_dict_lookup_value (options, "device-id", G_VARIANT_TYPE_STRING);
 
-        g_action_group_activate_action(G_ACTION_GROUP(g_application), "device-id", var);
-        return 0;
-    }
+    g_action_group_activate_action(G_ACTION_GROUP(g_application), "device-id", var);
+    return 0;
+  }
 
-    /* --quit */
-    if (g_variant_dict_contains (options, "quit") || g_variant_dict_contains (options, "q"))
-    {
-        g_action_group_activate_action(G_ACTION_GROUP(g_application), "quit", NULL);
-        return 0;
-    }
+  /* --quit */
+  if (g_variant_dict_contains (options, "quit") || g_variant_dict_contains (options, "q"))
+  {
+    g_action_group_activate_action(G_ACTION_GROUP(g_application), "quit", NULL);
+    return 0;
+  }
 
-    /* default action */
-    g_action_group_activate_action(G_ACTION_GROUP(g_application), "activate", NULL);
+  /* default action */
+  g_action_group_activate_action(G_ACTION_GROUP(g_application), "activate", NULL);
 
-    return 0;
+  return 0;
 }
 
 static void
 xfpm_settings_app_class_init (XfpmSettingsAppClass *class)
 {
-    GApplicationClass *gapplication_class = G_APPLICATION_CLASS (class);
+  GApplicationClass *gapplication_class = G_APPLICATION_CLASS (class);
 
-    gapplication_class->handle_local_options = xfpm_settings_app_local_options;
-    gapplication_class->startup              = xfpm_settings_app_startup;
-    gapplication_class->activate             = xfpm_settings_app_activate;
+  gapplication_class->handle_local_options = xfpm_settings_app_local_options;
+  gapplication_class->startup              = xfpm_settings_app_startup;
+  gapplication_class->activate             = xfpm_settings_app_activate;
 }
 
 XfpmSettingsApp *
 xfpm_settings_app_new (void)
 {
-    return g_object_new (XFPM_TYPE_SETTINGS_APP,
-                         "application-id", "org.xfce.PowerManager.Settings",
-                         "flags", G_APPLICATION_FLAGS_NONE,
-                         NULL);
+  return g_object_new (XFPM_TYPE_SETTINGS_APP,
+                       "application-id", "org.xfce.PowerManager.Settings",
+                       "flags", G_APPLICATION_FLAGS_NONE,
+                       NULL);
 }
diff --git a/settings/xfpm-settings-app.h b/settings/xfpm-settings-app.h
index b6517d39..9816d400 100644
--- a/settings/xfpm-settings-app.h
+++ b/settings/xfpm-settings-app.h
@@ -41,18 +41,17 @@ typedef struct _XfpmSettingsAppPrivate  XfpmSettingsAppPrivate;
 
 struct _XfpmSettingsApp
 {
-    GtkApplication               parent;
-    XfpmSettingsAppPrivate      *priv;
+  GtkApplication               parent;
+  XfpmSettingsAppPrivate      *priv;
 };
 
 struct _XfpmSettingsAppClass
 {
-    GtkApplicationClass    parent_class;
+  GtkApplicationClass    parent_class;
 };
 
 
 GType                xfpm_settings_app_get_type        (void) G_GNUC_CONST;
-
 XfpmSettingsApp     *xfpm_settings_app_new             (void);
 
 
diff --git a/settings/xfpm-settings-main.c b/settings/xfpm-settings-main.c
index 88c71c84..555b19cb 100644
--- a/settings/xfpm-settings-main.c
+++ b/settings/xfpm-settings-main.c
@@ -38,8 +38,7 @@
 
 int main (int argc, char **argv)
 {
+  xfce_textdomain(GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
 
-    xfce_textdomain(GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
-
-    return g_application_run (G_APPLICATION (xfpm_settings_app_new ()), argc, argv);
+  return g_application_run (G_APPLICATION (xfpm_settings_app_new ()), argc, argv);
 }
diff --git a/settings/xfpm-settings.c b/settings/xfpm-settings.c
index 18498deb..5e86a934 100644
--- a/settings/xfpm-settings.c
+++ b/settings/xfpm-settings.c
@@ -50,18 +50,18 @@
 #include "xfpm-enum-glib.h"
 #include "xfpm-enum.h"
 
-#define BRIGHTNESS_DISABLED 	9
-
-static  GtkApplication *app			= NULL;
-static 	GtkBuilder *xml 			= NULL;
-static  GtkWidget  *nt				= NULL;
-
-static  GtkWidget *on_battery_display_blank	= NULL;
-static  GtkWidget *on_battery_dpms_sleep 	= NULL;
-static  GtkWidget *on_battery_dpms_off  	= NULL;
-static  GtkWidget *on_ac_display_blank		= NULL;
-static  GtkWidget *on_ac_dpms_sleep 		= NULL;
-static  GtkWidget *on_ac_dpms_off 		= NULL;
+#define BRIGHTNESS_DISABLED   9
+
+static  GtkApplication *app     = NULL;
+static  GtkBuilder *xml       = NULL;
+static  GtkWidget  *nt        = NULL;
+
+static  GtkWidget *on_battery_display_blank = NULL;
+static  GtkWidget *on_battery_dpms_sleep  = NULL;
+static  GtkWidget *on_battery_dpms_off    = NULL;
+static  GtkWidget *on_ac_display_blank    = NULL;
+static  GtkWidget *on_ac_dpms_sleep     = NULL;
+static  GtkWidget *on_ac_dpms_off     = NULL;
 static  GtkWidget *sideview                 = NULL; /* Sidebar tree view - all devices are in the sideview */
 static  GtkWidget *device_details_notebook  = NULL; /* Displays the details of a deivce */
 
@@ -96,566 +96,535 @@ static gint devices_page_num;
 
 enum
 {
-    COL_SIDEBAR_ICON,
-    COL_SIDEBAR_NAME,
-    COL_SIDEBAR_INT,
-    COL_SIDEBAR_BATTERY_DEVICE, /* Pointer to the UpDevice */
-    COL_SIDEBAR_OBJECT_PATH,    /* UpDevice object path */
-    COL_SIDEBAR_SIGNAL_ID,      /* device changed callback id */
-    COL_SIDEBAR_VIEW,           /* Pointer to GtkTreeView of the devcie details */
-    NCOLS_SIDEBAR
+  COL_SIDEBAR_ICON,
+  COL_SIDEBAR_NAME,
+  COL_SIDEBAR_INT,
+  COL_SIDEBAR_BATTERY_DEVICE, /* Pointer to the UpDevice */
+  COL_SIDEBAR_OBJECT_PATH,    /* UpDevice object path */
+  COL_SIDEBAR_SIGNAL_ID,      /* device changed callback id */
+  COL_SIDEBAR_VIEW,           /* Pointer to GtkTreeView of the devcie details */
+  NCOLS_SIDEBAR
 };
 
 enum
 {
-    XFPM_DEVICE_INFO_NAME,
-    XFPM_DEVICE_INFO_VALUE,
-    XFPM_DEVICE_INFO_LAST
+  XFPM_DEVICE_INFO_NAME,
+  XFPM_DEVICE_INFO_VALUE,
+  XFPM_DEVICE_INFO_LAST
 };
 
 /*
  * GtkBuilder callbacks
  */
-void	    brightness_level_on_ac		   (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void 	    brightness_level_on_battery 	   (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void	    battery_critical_changed_cb 	   (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        inactivity_on_ac_value_changed_cb      (GtkWidget *widget,
-						    XfconfChannel *channel);
-
-void        inactivity_on_battery_value_changed_cb (GtkWidget *widget,
-						    XfconfChannel *channel);
-
-void        button_sleep_changed_cb                (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        button_power_changed_cb                 (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        button_hibernate_changed_cb            (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        button_battery_changed_cb              (GtkWidget *w,
-                                                    XfconfChannel *channel);
-
-void        on_sleep_mode_changed_cb      (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        dpms_toggled_cb                        (GtkWidget *w,
-                                                    gboolean is_active,
-                                                    XfconfChannel *channel);
-
-void        sleep_on_battery_value_changed_cb      (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        display_blank_on_battery_value_changed_cb (GtkWidget *w,
-						       XfconfChannel *channel);
-
-void        off_on_battery_value_changed_cb        (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        display_blank_on_ac_value_changed_cb   (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        sleep_on_ac_value_changed_cb           (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        off_on_ac_value_changed_cb             (GtkWidget *w,
-						    XfconfChannel *channel);
-
-gchar      *format_dpms_value_cb                   (gint value);
-
-gchar      *format_inactivity_value_cb             (gint value);
-
-gchar      *format_brightness_value_cb             (gint value);
-
-gchar      *format_brightness_percentage_cb        (gint value);
-
-void        brightness_on_battery_value_changed_cb (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        brightness_on_ac_value_changed_cb      (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        on_battery_lid_changed_cb              (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        on_ac_lid_changed_cb                   (GtkWidget *w,
-						    XfconfChannel *channel);
-
-void        critical_level_value_changed_cb        (GtkSpinButton *w,
-						    XfconfChannel *channel);
-
-void        lock_screen_toggled_cb                 (GtkWidget *w,
-						    XfconfChannel *channel);
-
-static void view_cursor_changed_cb 		   (GtkTreeView *view,
-						    gpointer *user_data);
-void        on_ac_sleep_mode_changed_cb 	   (GtkWidget *w,
-						    XfconfChannel *channel);
-void        on_battery_sleep_mode_changed_cb	   (GtkWidget *w,
-						    XfconfChannel *channel);
-
+void        brightness_level_on_ac                     (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        brightness_level_on_battery                (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        battery_critical_changed_cb                (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        inactivity_on_ac_value_changed_cb          (GtkWidget *widget,
+                                                        XfconfChannel *channel);
+void        inactivity_on_battery_value_changed_cb     (GtkWidget *widget,
+                                                        XfconfChannel *channel);
+void        button_sleep_changed_cb                    (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        button_power_changed_cb                    (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        button_hibernate_changed_cb                (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        button_battery_changed_cb                  (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        on_sleep_mode_changed_cb                   (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        dpms_toggled_cb                            (GtkWidget *w,
+                                                        gboolean is_active,
+                                                        XfconfChannel *channel);
+void        sleep_on_battery_value_changed_cb          (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        display_blank_on_battery_value_changed_cb  (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        off_on_battery_value_changed_cb            (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        display_blank_on_ac_value_changed_cb       (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        sleep_on_ac_value_changed_cb               (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        off_on_ac_value_changed_cb                 (GtkWidget *w,
+                                                        XfconfChannel *channel);
+gchar      *format_dpms_value_cb                       (gint value);
+gchar      *format_inactivity_value_cb                 (gint value);
+gchar      *format_brightness_value_cb                 (gint value);
+gchar      *format_brightness_percentage_cb            (gint value);
+void        brightness_on_battery_value_changed_cb     (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        brightness_on_ac_value_changed_cb          (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        on_battery_lid_changed_cb                  (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        on_ac_lid_changed_cb                       (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        critical_level_value_changed_cb            (GtkSpinButton *w,
+                                                        XfconfChannel *channel);
+void        lock_screen_toggled_cb                     (GtkWidget *w,
+                                                        XfconfChannel *channel);
+static void view_cursor_changed_cb                     (GtkTreeView *view,
+                                                        gpointer *user_data);
+void        on_ac_sleep_mode_changed_cb                (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        on_battery_sleep_mode_changed_cb           (GtkWidget *w,
+                                                        XfconfChannel *channel);
 /* Light Locker Integration */
-gchar      *format_light_locker_value_cb           (gint value);
-
+gchar      *format_light_locker_value_cb               (gint value);
 void        light_locker_late_locking_value_changed_cb (GtkWidget *w,
                                                         XfconfChannel *channel);
-
-void        light_locker_automatic_locking_changed_cb (GtkWidget *w,
-                                                       XfconfChannel *channel);
-
-void        xfpm_update_logind_handle_lid_switch   (XfconfChannel *channel);
+void        light_locker_automatic_locking_changed_cb  (GtkWidget *w,
+                                                        XfconfChannel *channel);
+void        xfpm_update_logind_handle_lid_switch       (XfconfChannel *channel);
 /* END Light Locker Integration */
 
 static void
 update_label (GtkWidget *label, GtkWidget *scale, gchar* (*format)(gint))
 {
-    gint value = (gint) gtk_range_get_value (GTK_RANGE (scale));
+  gint value = (gint) gtk_range_get_value (GTK_RANGE (scale));
 
-    gchar *formatted_value = format (value);
-    gtk_label_set_text (GTK_LABEL (label), formatted_value);
-    g_free (formatted_value);
+  gchar *formatted_value = format (value);
+  gtk_label_set_text (GTK_LABEL (label), formatted_value);
+  g_free (formatted_value);
 }
 
 void brightness_level_on_ac (GtkWidget *w,  XfconfChannel *channel)
 {
-    guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
+  guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, val) )
-    {
-	g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_AC);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, val) )
+  {
+    g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_AC);
+  }
 
-    update_label (label_brightness_level_on_ac, w, format_brightness_percentage_cb);
+  update_label (label_brightness_level_on_ac, w, format_brightness_percentage_cb);
 }
 
 void brightness_level_on_battery (GtkWidget *w,  XfconfChannel *channel)
 {
-     guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
+   guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, val) )
-    {
-	g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_BATTERY);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, val) )
+  {
+    g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_BATTERY);
+  }
 
-    update_label (label_brightness_level_on_battery, w, format_brightness_percentage_cb);
+  update_label (label_brightness_level_on_battery, w, format_brightness_percentage_cb);
 }
 
 void
 battery_critical_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get(model,
+                     &selected_row,
+                     1,
+                     &value,
+                     -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", CRITICAL_BATT_ACTION_CFG);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", CRITICAL_BATT_ACTION_CFG);
+  }
 }
 
 void
 inactivity_on_ac_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
 {
-    gint value    = (gint)gtk_range_get_value (GTK_RANGE (widget));
+  gint value    = (gint)gtk_range_get_value (GTK_RANGE (widget));
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, value))
-    {
-	g_critical ("Cannot set value for property %s\n", ON_AC_INACTIVITY_TIMEOUT);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_AC_INACTIVITY_TIMEOUT);
+  }
 
-    update_label (label_inactivity_on_ac, widget, format_inactivity_value_cb);
+  update_label (label_inactivity_on_ac, widget, format_inactivity_value_cb);
 }
 
 void
 inactivity_on_battery_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
 {
-    gint value    = (gint)gtk_range_get_value (GTK_RANGE (widget));
+  gint value    = (gint)gtk_range_get_value (GTK_RANGE (widget));
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, value))
-    {
-	g_critical ("Cannot set value for property %s\n", ON_BATTERY_INACTIVITY_TIMEOUT);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_BATTERY_INACTIVITY_TIMEOUT);
+  }
 
-    update_label (label_inactivity_on_battery, widget, format_inactivity_value_cb);
+  update_label (label_inactivity_on_battery, widget, format_inactivity_value_cb);
 }
 
 void
 button_sleep_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get(model,
+                     &selected_row,
+                     1,
+                     &value,
+                     -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, value ) )
-    {
-	g_critical ("Cannot set value for property %s\n", SLEEP_SWITCH_CFG);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, value ) )
+  {
+    g_critical ("Cannot set value for property %s\n", SLEEP_SWITCH_CFG);
+  }
 }
 
 void
 button_power_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get(model,
+                     &selected_row,
+                     1,
+                     &value,
+                     -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", POWER_SWITCH_CFG);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", POWER_SWITCH_CFG);
+  }
 }
 
 void
 button_hibernate_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get (model,
+                      &selected_row,
+                      1,
+                      &value,
+                      -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, value ) )
-    {
-	g_critical ("Cannot set value for property %s\n", HIBERNATE_SWITCH_CFG);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, value ) )
+  {
+    g_critical ("Cannot set value for property %s\n", HIBERNATE_SWITCH_CFG);
+  }
 }
 
 void
 button_battery_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-        return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get (model,
+                      &selected_row,
+                      1,
+                      &value,
+                      -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, value ) )
-    {
-        g_critical ("Cannot set value for property %s\n", BATTERY_SWITCH_CFG);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, value ) )
+  {
+    g_critical ("Cannot set value for property %s\n", BATTERY_SWITCH_CFG);
+  }
 }
 
 void
 on_ac_sleep_mode_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    guint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  guint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-    return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+  return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get(model,
+                     &selected_row,
+                     1,
+                     &value,
+                     -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_AC);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_AC);
+  }
 }
 
 void
 on_battery_sleep_mode_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    guint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  guint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-    return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+  return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get(model,
+                     &selected_row,
+                     1,
+                     &value,
+                     -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_BATTERY);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_BATTERY);
+  }
 }
 
 void
 dpms_toggled_cb (GtkWidget *w, gboolean is_active, XfconfChannel *channel)
 {
-    xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, is_active);
-
-    gtk_widget_set_sensitive (on_ac_dpms_off, is_active);
-    gtk_widget_set_sensitive (on_ac_dpms_sleep, is_active);
-    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-label")), is_active);
-    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-label")), is_active);
-
-    if ( GTK_IS_WIDGET (on_battery_dpms_off ) )
-    {
-        gtk_widget_set_sensitive (on_battery_dpms_off, is_active);
-        gtk_widget_set_sensitive (on_battery_dpms_sleep, is_active);
-    }
+  xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, is_active);
+
+  gtk_widget_set_sensitive (on_ac_dpms_off, is_active);
+  gtk_widget_set_sensitive (on_ac_dpms_sleep, is_active);
+  gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-label")), is_active);
+  gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-label")), is_active);
+
+  if ( GTK_IS_WIDGET (on_battery_dpms_off ) )
+  {
+    gtk_widget_set_sensitive (on_battery_dpms_off, is_active);
+    gtk_widget_set_sensitive (on_battery_dpms_sleep, is_active);
+  }
 }
 
 void
 display_blank_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkWidget *brg;
-    gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
-    gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep));
-    gint brightness_value;
+  GtkWidget *brg;
+  gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
+  gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep));
+  gint brightness_value;
 
-    if ( sleep_value != 0 )
+  if ( sleep_value != 0 )
+  {
+    if ( blank_value >= sleep_value )
     {
-	if ( blank_value >= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), blank_value + 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), blank_value + 1 );
     }
+  }
 
-    if ( lcd_brightness )
-    {
-	brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
-	brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
+  if ( lcd_brightness )
+  {
+    brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
+    brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
 
-	if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
-	{
-	    gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
-	}
+    if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
+    {
+      gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
     }
+  }
 
-    update_label (label_display_blank_on_battery, w, format_dpms_value_cb);
+  update_label (label_display_blank_on_battery, w, format_dpms_value_cb);
 }
 
 void
 sleep_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkWidget *brg;
-    gint off_value    = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_off));
-    gint sleep_value  = (gint) gtk_range_get_value (GTK_RANGE (w));
-    gint blank_value  = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
-    gint brightness_value;
+  GtkWidget *brg;
+  gint off_value    = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_off));
+  gint sleep_value  = (gint) gtk_range_get_value (GTK_RANGE (w));
+  gint blank_value  = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
+  gint brightness_value;
 
-    if ( off_value != 0 )
+  if ( off_value != 0 )
+  {
+    if ( sleep_value >= off_value )
     {
-	if ( sleep_value >= off_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), sleep_value + 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), sleep_value + 1 );
     }
+  }
 
-    if ( blank_value != 0 )
+  if ( blank_value != 0 )
+  {
+    if ( blank_value >= sleep_value )
     {
-	if ( blank_value >= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_battery_display_blank), sleep_value - 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_battery_display_blank), sleep_value - 1 );
     }
+  }
 
-    if ( lcd_brightness )
-    {
-	brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
-	brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
-
-	if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
-	{
-	    gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
-	}
-    }
+  if ( lcd_brightness )
+  {
+    brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
+    brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, sleep_value))
+    if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
     {
-	g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_SLEEP);
+        gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
     }
+  }
 
-    update_label (label_dpms_sleep_on_battery, w, format_dpms_value_cb);
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, sleep_value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_SLEEP);
+  }
+
+  update_label (label_dpms_sleep_on_battery, w, format_dpms_value_cb);
 }
 
 void
 off_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    gint off_value    = (gint)gtk_range_get_value (GTK_RANGE(w));
-    gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE(on_battery_dpms_sleep));
+  gint off_value    = (gint)gtk_range_get_value (GTK_RANGE(w));
+  gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE(on_battery_dpms_sleep));
 
-    if ( sleep_value != 0 )
+  if ( sleep_value != 0 )
+  {
+    if ( off_value <= sleep_value )
     {
-	if ( off_value <= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), off_value -1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), off_value -1 );
     }
+  }
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, off_value))
-    {
-	g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_OFF);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, off_value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_OFF);
+  }
 
-    update_label (label_dpms_off_on_battery, w, format_dpms_value_cb);
+  update_label (label_dpms_off_on_battery, w, format_dpms_value_cb);
 }
 
 void
 display_blank_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkWidget *brg;
-    gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
-    gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep));
-    gint brightness_value;
+  GtkWidget *brg;
+  gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
+  gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep));
+  gint brightness_value;
 
-    if ( sleep_value != 0 )
+  if ( sleep_value != 0 )
+  {
+    if ( blank_value >= sleep_value )
     {
-	if ( blank_value >= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), blank_value + 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), blank_value + 1 );
     }
+  }
 
-    if ( lcd_brightness )
-    {
-	brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
-	brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
+  if ( lcd_brightness )
+  {
+    brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
+    brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
 
-	if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
-	{
-	    gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
-	}
+    if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
+    {
+      gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
     }
+  }
 
-    update_label (label_display_blank_on_ac, w, format_dpms_value_cb);
+  update_label (label_display_blank_on_ac, w, format_dpms_value_cb);
 }
 
 void
 sleep_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkWidget *brg;
+  GtkWidget *brg;
 
-    gint brightness_value;
-    gint off_value    = (gint)gtk_range_get_value (GTK_RANGE (on_ac_dpms_off));
-    gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE (w));
-    gint blank_value  = (gint)gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
+  gint brightness_value;
+  gint off_value    = (gint)gtk_range_get_value (GTK_RANGE (on_ac_dpms_off));
+  gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE (w));
+  gint blank_value  = (gint)gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
 
-    if ( off_value > 60 || sleep_value > 60 )
-    	return;
+  if ( off_value > 60 || sleep_value > 60 )
+    return;
 
-    if ( off_value != 0 )
+  if ( off_value != 0 )
+  {
+    if ( sleep_value >= off_value )
     {
-	if ( sleep_value >= off_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), sleep_value + 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), sleep_value + 1 );
     }
+  }
 
-    if ( blank_value != 0 )
+  if ( blank_value != 0 )
+  {
+    if ( blank_value >= sleep_value )
     {
-	if ( blank_value >= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_ac_display_blank), sleep_value - 1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_ac_display_blank), sleep_value - 1 );
     }
+  }
 
-    if ( lcd_brightness )
-    {
-	brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
+  if ( lcd_brightness )
+  {
+    brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
 
-	brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
+    brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
 
-	if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
-	{
-	    gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
-	}
-    }
-
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, sleep_value))
+    if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
     {
-	g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_SLEEP);
+      gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
     }
+  }
+
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, sleep_value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_SLEEP);
+  }
 
-    update_label (label_dpms_sleep_on_ac, w, format_dpms_value_cb);
+  update_label (label_dpms_sleep_on_ac, w, format_dpms_value_cb);
 }
 
 void
 off_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    gint off_value    = (gint)gtk_range_get_value (GTK_RANGE(w));
-    gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE(on_ac_dpms_sleep));
+  gint off_value    = (gint)gtk_range_get_value (GTK_RANGE(w));
+  gint sleep_value  = (gint)gtk_range_get_value (GTK_RANGE(on_ac_dpms_sleep));
 
-    if ( off_value > 60 || sleep_value > 60 )
-    	return;
+  if ( off_value > 60 || sleep_value > 60 )
+    return;
 
-    if ( sleep_value != 0 )
+  if ( sleep_value != 0 )
+  {
+    if ( off_value <= sleep_value )
     {
-	if ( off_value <= sleep_value )
-	{
-	    gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), off_value -1 );
-	}
+      gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), off_value -1 );
     }
+  }
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, off_value))
-    {
-	g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_OFF);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, off_value))
+  {
+    g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_OFF);
+  }
 
-    update_label (label_dpms_off_on_ac, w, format_dpms_value_cb);
+  update_label (label_dpms_off_on_ac, w, format_dpms_value_cb);
 }
 
 /*
@@ -664,40 +633,40 @@ off_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 gchar *
 format_dpms_value_cb (gint value)
 {
-    if ( value == 0 )
-        return g_strdup (_("Never"));
+  if ( value == 0 )
+    return g_strdup (_("Never"));
 
-    if ( value == 1 )
-        return g_strdup (_("One minute"));
+  if ( value == 1 )
+    return g_strdup (_("One minute"));
 
-    return g_strdup_printf ("%d %s", value, _("minutes"));
+  return g_strdup_printf ("%d %s", value, _("minutes"));
 }
 
 
 gchar *
 format_inactivity_value_cb (gint value)
 {
-    gint h, min;
-
-    if ( value <= 14 )
-        return g_strdup (_("Never"));
-    else if ( value < 60 )
-        return g_strdup_printf ("%d %s", value, _("minutes"));
-    else if ( value == 60 )
-        return g_strdup (_("One hour"));
-
-    /* value > 60 */
-    h = value/60;
-    min = value%60;
-
-    if ( h <= 1 )
-	if ( min == 0 )      return g_strdup_printf ("%s", _("One hour"));
-	else if ( min == 1 ) return g_strdup_printf ("%s %s", _("One hour"),  _("one minute"));
-	else                 return g_strdup_printf ("%s %d %s", _("One hour"), min, _("minutes"));
-    else
-	if ( min == 0 )      return g_strdup_printf ("%d %s", h, _("hours"));
-	else if ( min == 1 ) return g_strdup_printf ("%d %s %s", h, _("hours"), _("one minute"));
-	else                 return g_strdup_printf ("%d %s %d %s", h, _("hours"), min, _("minutes"));
+  gint h, min;
+
+  if ( value <= 14 )
+    return g_strdup (_("Never"));
+  else if ( value < 60 )
+    return g_strdup_printf ("%d %s", value, _("minutes"));
+  else if ( value == 60 )
+    return g_strdup (_("One hour"));
+
+  /* value > 60 */
+  h = value/60;
+  min = value%60;
+
+  if ( h <= 1 )
+    if ( min == 0 )      return g_strdup_printf ("%s", _("One hour"));
+    else if ( min == 1 ) return g_strdup_printf ("%s %s", _("One hour"),  _("one minute"));
+    else                 return g_strdup_printf ("%s %d %s", _("One hour"), min, _("minutes"));
+  else
+    if ( min == 0 )      return g_strdup_printf ("%d %s", h, _("hours"));
+    else if ( min == 1 ) return g_strdup_printf ("%d %s %s", h, _("hours"), _("one minute"));
+    else                 return g_strdup_printf ("%d %s %d %s", h, _("hours"), min, _("minutes"));
 }
 
 /*
@@ -706,162 +675,162 @@ format_inactivity_value_cb (gint value)
 gchar *
 format_brightness_value_cb (gint value)
 {
-    if ( value <= 9 )
-        return g_strdup (_("Never"));
+  if ( value <= 9 )
+    return g_strdup (_("Never"));
 
-    return g_strdup_printf ("%d %s", value, _("seconds"));
+  return g_strdup_printf ("%d %s", value, _("seconds"));
 }
 
 gchar *
 format_brightness_percentage_cb (gint value)
 {
-    return g_strdup_printf ("%d %s", value, _("%"));
+  return g_strdup_printf ("%d %s", value, _("%"));
 }
 
 void
 brightness_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    gint value    = (gint)gtk_range_get_value (GTK_RANGE (w));
-    gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep) );
+  gint value    = (gint)gtk_range_get_value (GTK_RANGE (w));
+  gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep) );
 
-    if ( value != BRIGHTNESS_DISABLED )
+  if ( value != BRIGHTNESS_DISABLED )
+  {
+    if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
     {
-	if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
-	{
-	    gtk_range_set_value (GTK_RANGE (on_battery_dpms_sleep), (value / 60) + 1);
-	}
+      gtk_range_set_value (GTK_RANGE (on_battery_dpms_sleep), (value / 60) + 1);
     }
+  }
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, value))
-    {
-	g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_BATTERY);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, value))
+  {
+    g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_BATTERY);
+  }
 
-    update_label (label_brightness_inactivity_on_battery, w, format_brightness_value_cb);
+  update_label (label_brightness_inactivity_on_battery, w, format_brightness_value_cb);
 }
 
 void
 brightness_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    gint value    = (gint)gtk_range_get_value (GTK_RANGE (w));
-    gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep) );
+  gint value    = (gint)gtk_range_get_value (GTK_RANGE (w));
+  gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep) );
 
-    if ( value != BRIGHTNESS_DISABLED )
+  if ( value != BRIGHTNESS_DISABLED )
+  {
+    if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
     {
-	if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
-	{
-	    gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), (value / 60) + 1);
-	}
+      gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), (value / 60) + 1);
     }
+  }
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, value))
-    {
-	g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_AC);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, value))
+  {
+    g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_AC);
+  }
 
-    update_label (label_brightness_inactivity_on_ac, w, format_brightness_value_cb);
+  update_label (label_brightness_inactivity_on_ac, w, format_brightness_value_cb);
 }
 
 void
 on_battery_lid_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get (model,
+                      &selected_row,
+                      1,
+                      &value,
+                      -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_BATTERY_CFG);
-    }
-    xfpm_update_logind_handle_lid_switch (channel);
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_BATTERY_CFG);
+  }
+  xfpm_update_logind_handle_lid_switch (channel);
 }
 
 void
 on_ac_lid_changed_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint value = 0;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint value = 0;
 
-    if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
-	return;
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
+    return;
 
-    model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       1,
-                       &value,
-                       -1);
+  gtk_tree_model_get (model,
+                      &selected_row,
+                      1,
+                      &value,
+                      -1);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, value) )
-    {
-	g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_AC_CFG);
-    }
-    xfpm_update_logind_handle_lid_switch (channel);
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, value) )
+  {
+    g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_AC_CFG);
+  }
+  xfpm_update_logind_handle_lid_switch (channel);
 }
 
 void
 critical_level_value_changed_cb (GtkSpinButton *w, XfconfChannel *channel)
 {
-    guint val = (guint) gtk_spin_button_get_value (w);
+  guint val = (guint) gtk_spin_button_get_value (w);
 
-    if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, val) )
-    {
-	g_critical ("Unable to set value %d for property %s\n", val, CRITICAL_POWER_LEVEL);
-    }
+  if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, val) )
+  {
+    g_critical ("Unable to set value %d for property %s\n", val, CRITICAL_POWER_LEVEL);
+  }
 }
 
 void
 lock_screen_toggled_cb (GtkWidget *w, XfconfChannel *channel)
 {
-    XfconfChannel *session_channel = xfconf_channel_get ("xfce4-session");
-    gboolean val = (gint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(w));
-
-    if ( !xfconf_channel_set_bool (session_channel, "/shutdown/LockScreen", val) )
-    {
-	g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
-    }
-
-    if ( !xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, val) )
-    {
-	g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
-    }
-
-    /* Light Locker Integration */
-    if ( light_locker_settings )
-    {
-        GVariant *variant;
-        variant = g_variant_new_boolean (val);
-        if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
-            g_critical ("Cannot set value for property lock-on-suspend\n");
+  XfconfChannel *session_channel = xfconf_channel_get ("xfce4-session");
+  gboolean val = (gint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(w));
+
+  if ( !xfconf_channel_set_bool (session_channel, "/shutdown/LockScreen", val) )
+  {
+    g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
+  }
+
+  if ( !xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, val) )
+  {
+    g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
+  }
+
+  /* Light Locker Integration */
+  if ( light_locker_settings )
+  {
+    GVariant *variant;
+    variant = g_variant_new_boolean (val);
+    if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
+      g_critical ("Cannot set value for property lock-on-suspend\n");
 
-	xfpm_update_logind_handle_lid_switch (channel);
-    }
-    /* END Light Locker Integration */
+  xfpm_update_logind_handle_lid_switch (channel);
+  }
+  /* END Light Locker Integration */
 }
 
 /* Light Locker Integration */
 void
 xfpm_update_logind_handle_lid_switch (XfconfChannel *channel)
 {
-    gboolean lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
-    guint lid_switch_on_ac = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
-    guint lid_switch_on_battery = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
+  gboolean lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
+  guint lid_switch_on_ac = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
+  guint lid_switch_on_battery = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
 
-    // logind-handle-lid-switch = true when: lock_on_suspend == true and (lid_switch_on_ac == suspend or lid_switch_on_battery == suspend)
-    xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOGIND_HANDLE_LID_SWITCH, lock_on_suspend && (lid_switch_on_ac == 1 || lid_switch_on_battery == 1));
+  // logind-handle-lid-switch = true when: lock_on_suspend == true and (lid_switch_on_ac == suspend or lid_switch_on_battery == suspend)
+  xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOGIND_HANDLE_LID_SWITCH, lock_on_suspend && (lid_switch_on_ac == 1 || lid_switch_on_battery == 1));
 }
 /* END Light Locker Integration */
 
@@ -871,236 +840,236 @@ xfpm_settings_on_battery (XfconfChannel *channel, gboolean auth_suspend,
                           gboolean can_hibernate, gboolean can_shutdown,
                           gboolean has_lcd_brightness, gboolean has_lid)
 {
-    gboolean valid, handle_dpms;
-    gint list_value;
-    gint val;
-    GtkListStore *list_store;
-    GtkTreeIter iter;
-    GtkWidget *inact_timeout, *inact_action;
-    GtkWidget *battery_critical;
-    GtkWidget *lid;
-    GtkWidget *brg;
-    GtkWidget *brg_level;
-
-    /*
-     * Inactivity sleep mode on battery
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-battery"));
-    gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
-
-    if ( can_suspend )
-    {
+  gboolean valid, handle_dpms;
+  gint list_value;
+  gint val;
+  GtkListStore *list_store;
+  GtkTreeIter iter;
+  GtkWidget *inact_timeout, *inact_action;
+  GtkWidget *battery_critical;
+  GtkWidget *lid;
+  GtkWidget *brg;
+  GtkWidget *brg_level;
+
+  /*
+   * Inactivity sleep mode on battery
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-battery"));
+  gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
+
+  if ( can_suspend )
+  {
     gtk_list_store_append (list_store, &iter);
     gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-    }
-    else if ( !auth_suspend )
-    {
+  }
+  else if ( !auth_suspend )
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not permitted"));
-    }
-    else
-    {
+  }
+  else
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not supported"));
-    }
+  }
 
-    if ( can_hibernate )
-    {
+  if ( can_hibernate )
+  {
     gtk_list_store_append (list_store, &iter);
     gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-    }
-    else if ( !auth_hibernate )
-    {
+  }
+  else if ( !auth_hibernate )
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not permitted"));
-    }
-    else
-    {
+  }
+  else
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not supported"));
-    }
+  }
 
-    gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
+  gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
 
-    val = xfconf_channel_get_uint (channel,
-                                   XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY,
-                                   XFPM_DO_HIBERNATE);
+  val = xfconf_channel_get_uint (channel,
+                                 XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY,
+                                 XFPM_DO_HIBERNATE);
 
-    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	  valid;
-	  valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+  for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+        valid;
+        valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+  {
+    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                        1, &list_value, -1);
+    if ( val == list_value )
     {
-	gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-			    1, &list_value, -1);
-	if ( val == list_value )
-	{
-	    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
-	    break;
-	}
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
+      break;
     }
+  }
 
-    /*
-     * Inactivity timeout on battery
-     */
-    inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery"));
+  /*
+   * Inactivity timeout on battery
+   */
+  inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery"));
 
-    if ( !can_suspend && !can_hibernate )
-    {
+  if ( !can_suspend && !can_hibernate )
+  {
     gtk_widget_set_sensitive (inact_timeout, FALSE);
     gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not supported"));
-    }
-    else  if ( !auth_suspend && !auth_hibernate )
-    {
+  }
+  else  if ( !auth_suspend && !auth_hibernate )
+  {
     gtk_widget_set_sensitive (inact_timeout, FALSE);
     gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not permitted"));
-    }
+  }
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, 14);
-    gtk_range_set_value (GTK_RANGE (inact_timeout), val);
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, 14);
+  gtk_range_set_value (GTK_RANGE (inact_timeout), val);
 
 
-    /*
-     * Battery critical
-     */
-    battery_critical = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-action-combo"));
+  /*
+   * Battery critical
+   */
+  battery_critical = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-action-combo"));
 
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
-    gtk_combo_box_set_model (GTK_COMBO_BOX(battery_critical), GTK_TREE_MODEL(list_store));
+  gtk_combo_box_set_model (GTK_COMBO_BOX(battery_critical), GTK_TREE_MODEL(list_store));
 
-    gtk_list_store_append(list_store, &iter);
-    gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
+  gtk_list_store_append(list_store, &iter);
+  gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
 
-    if ( can_suspend && auth_suspend )
-    {
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-    }
-
-    if ( can_hibernate && auth_hibernate )
-    {
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-    }
+  if ( can_suspend && auth_suspend )
+  {
+    gtk_list_store_append(list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
+  }
 
-    if ( can_shutdown )
-    {
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
-    }
+  if ( can_hibernate && auth_hibernate )
+  {
+    gtk_list_store_append(list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
+  }
 
+  if ( can_shutdown )
+  {
     gtk_list_store_append(list_store, &iter);
-    gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+    gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
+  }
+
+  gtk_list_store_append(list_store, &iter);
+  gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, XFPM_DO_NOTHING);
+
+  for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+        valid;
+        valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+  {
+    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                        1, &list_value, -1);
+    if ( val == list_value )
+    {
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_critical), &iter);
+      break;
+    }
+  }
+
+  /*
+   * DPMS settings when running on battery power
+   */
+  handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, 5);
+  gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), val);
+  gtk_widget_set_sensitive (on_battery_dpms_sleep, handle_dpms);
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, 10);
+  gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), val);
+  gtk_widget_set_sensitive (on_battery_dpms_off, handle_dpms);
+
+  /*
+   * Lid switch settings on battery
+   */
+  lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-combo"));
+  if ( has_lid )
+  {
+    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, XFPM_DO_NOTHING);
+    gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
 
-    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	  valid;
-	  valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
+
+    if ( can_suspend && auth_suspend )
     {
-	gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-			    1, &list_value, -1);
-	if ( val == list_value )
-	{
-	    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_critical), &iter);
-	    break;
-	}
+      gtk_list_store_append(list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
     }
 
-    /*
-     * DPMS settings when running on battery power
-     */
-    handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
+    if ( can_hibernate && auth_hibernate)
+    {
+      gtk_list_store_append(list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
+    }
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, 5);
-    gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), val);
-    gtk_widget_set_sensitive (on_battery_dpms_sleep, handle_dpms);
+    gtk_list_store_append(list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, 10);
-    gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), val);
-    gtk_widget_set_sensitive (on_battery_dpms_off, handle_dpms);
+    gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
 
-    /*
-     * Lid switch settings on battery
-     */
-    lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-combo"));
-    if ( has_lid )
-    {
-	list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-
-	gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
-
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
-
-	if ( can_suspend && auth_suspend )
-	{
-	    gtk_list_store_append(list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
-	}
-
-	if ( can_hibernate && auth_hibernate)
-	{
-	    gtk_list_store_append(list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
-	}
-
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
-
-	gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
-
-	val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
-
-	for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	      valid;
-	      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-	{
-	    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-				1, &list_value, -1);
-	    if ( val == list_value )
-	    {
-		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
-		break;
-	    }
-	}
-    }
-    else
-    {
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label")));
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-header")));
-      gtk_widget_hide (lid);
-    }
+    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
 
-    /*
-     * Brightness on battery
-     */
-    brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-battery"));
-    brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-battery"));
-    if ( has_lcd_brightness )
-    {
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+        gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                            1, &list_value, -1);
+      if ( val == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
+        break;
+      }
+    }
+    }
+  else
+  {
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label")));
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-header")));
+    gtk_widget_hide (lid);
+  }
+
+  /*
+   * Brightness on battery
+   */
+  brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-battery"));
+  brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-battery"));
+  if ( has_lcd_brightness )
+  {
     val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, 120);
     gtk_range_set_value (GTK_RANGE(brg), val);
 
     val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, 20);
     gtk_range_set_value (GTK_RANGE (brg_level), val);
-    }
-    else
-    {
+  }
+  else
+  {
     gtk_widget_hide (brg);
     gtk_widget_hide (brg_level);
-    }
-
-    label_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery-label"));
-    label_display_blank_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery-label"));
-    label_dpms_sleep_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery-label"));
-    label_dpms_off_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery-label"));
-    label_brightness_level_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-battery-label"));
-    label_brightness_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery-label"));
-
-    update_label (label_inactivity_on_battery, inact_timeout, format_inactivity_value_cb);
-    update_label (label_display_blank_on_battery, on_battery_display_blank, format_dpms_value_cb);
-    update_label (label_dpms_sleep_on_battery, on_battery_dpms_sleep, format_dpms_value_cb);
-    update_label (label_dpms_off_on_battery, on_battery_dpms_off, format_dpms_value_cb);
-    update_label (label_brightness_level_on_battery, brg_level, format_brightness_percentage_cb);
-    update_label (label_brightness_inactivity_on_battery, brg, format_brightness_value_cb);
+  }
+
+  label_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery-label"));
+  label_display_blank_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery-label"));
+  label_dpms_sleep_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery-label"));
+  label_dpms_off_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery-label"));
+  label_brightness_level_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-battery-label"));
+  label_brightness_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery-label"));
+
+  update_label (label_inactivity_on_battery, inact_timeout, format_inactivity_value_cb);
+  update_label (label_display_blank_on_battery, on_battery_display_blank, format_dpms_value_cb);
+  update_label (label_dpms_sleep_on_battery, on_battery_dpms_sleep, format_dpms_value_cb);
+  update_label (label_dpms_off_on_battery, on_battery_dpms_off, format_dpms_value_cb);
+  update_label (label_brightness_level_on_battery, brg_level, format_brightness_percentage_cb);
+  update_label (label_brightness_inactivity_on_battery, brg, format_brightness_value_cb);
 }
 
 static void
@@ -1109,186 +1078,185 @@ xfpm_settings_on_ac (XfconfChannel *channel, gboolean auth_suspend,
                      gboolean can_hibernate, gboolean has_lcd_brightness,
                      gboolean has_lid)
 {
-    gboolean valid, handle_dpms;
-    GtkWidget *inact_timeout, *inact_action;
-    GtkWidget *lid;
-    GtkWidget *brg;
-    GtkWidget *brg_level;
-    GtkListStore *list_store;
-    GtkTreeIter iter;
-    guint val;
-    guint list_value;
-
-    /*
-     * Inactivity sleep mode on AC
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-ac"));
-    gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
-
-    if ( can_suspend )
-    {
+  gboolean valid, handle_dpms;
+  GtkWidget *inact_timeout, *inact_action;
+  GtkWidget *lid;
+  GtkWidget *brg;
+  GtkWidget *brg_level;
+  GtkListStore *list_store;
+  GtkTreeIter iter;
+  guint val;
+  guint list_value;
+
+  /*
+   * Inactivity sleep mode on AC
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-ac"));
+  gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
+
+  if ( can_suspend )
+  {
     gtk_list_store_append (list_store, &iter);
     gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-    }
-    else if ( !auth_suspend )
-    {
+  }
+  else if ( !auth_suspend )
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not permitted"));
-    }
-    else
-    {
+  }
+  else
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not supported"));
-    }
+  }
 
-    if ( can_hibernate )
-    {
+  if ( can_hibernate )
+  {
     gtk_list_store_append (list_store, &iter);
     gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-    }
-    else if ( !auth_hibernate )
-    {
+  }
+  else if ( !auth_hibernate )
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not permitted"));
-    }
-    else
-    {
+  }
+  else
+  {
     gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not supported"));
-    }
+  }
 
-    gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
+  gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
 
-    val = xfconf_channel_get_uint (channel,
-                                   XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC,
-                                   XFPM_DO_SUSPEND);
+  val = xfconf_channel_get_uint (channel,
+                                 XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC,
+                                 XFPM_DO_SUSPEND);
 
-    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	  valid;
-	  valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+  for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+        valid;
+        valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+  {
+    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                        1, &list_value, -1);
+    if ( val == list_value )
     {
-	gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-			    1, &list_value, -1);
-	if ( val == list_value )
-	{
-	    gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
-	    break;
-	}
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
+      break;
     }
+  }
 
-    /*
-     * Inactivity timeout on AC
-     */
-    inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac"));
+  /*
+   * Inactivity timeout on AC
+   */
+  inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac"));
 
-    if ( !can_suspend && !can_hibernate )
-    {
+  if ( !can_suspend && !can_hibernate )
+  {
     gtk_widget_set_sensitive (inact_timeout, FALSE);
     gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not supported"));
-    }
-    else  if ( !auth_suspend && !auth_hibernate )
-    {
+  }
+  else  if ( !auth_suspend && !auth_hibernate )
+  {
     gtk_widget_set_sensitive (inact_timeout, FALSE);
     gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not permitted"));
-    }
-
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, 14);
-    gtk_range_set_value (GTK_RANGE (inact_timeout), val);
-
-    /*
-     * DPMS settings when running on AC power
-     */
-    handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
+  }
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, 14);
+  gtk_range_set_value (GTK_RANGE (inact_timeout), val);
+
+  /*
+   * DPMS settings when running on AC power
+   */
+  handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, 10);
+  gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), val);
+  gtk_widget_set_sensitive (on_ac_dpms_sleep, handle_dpms);
+
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, 15);
+  gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), val);
+  gtk_widget_set_sensitive (on_ac_dpms_off, handle_dpms);
+
+  /*
+   * Lid switch settings on AC power
+   */
+  lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-ac-combo"));
+  if ( has_lid )
+  {
+    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, 10);
-    gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), val);
-    gtk_widget_set_sensitive (on_ac_dpms_sleep, handle_dpms);
+    gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
 
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, 15);
-    gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), val);
-    gtk_widget_set_sensitive (on_ac_dpms_off, handle_dpms);
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
 
-    /*
-     * Lid switch settings on AC power
-     */
-    lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-ac-combo"));
-    if ( has_lid )
+    if ( can_suspend && auth_suspend )
     {
-	list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-
-	gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
-
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
-
-	if ( can_suspend && auth_suspend )
-	{
-	    gtk_list_store_append(list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
-	}
-
-	if ( can_hibernate && auth_hibernate )
-	{
-	    gtk_list_store_append(list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
-	}
-
-	gtk_list_store_append(list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
-
-	gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
-
-	val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
-	for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	      valid;
-	      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-	{
-	    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-				1, &list_value, -1);
-	    if ( val == list_value )
-	    {
-		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
-		break;
-	    }
-	}
+      gtk_list_store_append(list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
     }
-    else
+
+    if ( can_hibernate && auth_hibernate )
     {
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label1")));
-      gtk_widget_hide (lid);
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-plugged-in-header")));
+      gtk_list_store_append(list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
     }
 
-	/*
-	 * Brightness on AC power
-	 */
-	brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-ac"));
-	brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-ac"));
-	if ( has_lcd_brightness )
-	{
-	val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, 9);
-	gtk_range_set_value (GTK_RANGE(brg), val);
-
-	val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, 80);
-	gtk_range_set_value (GTK_RANGE (brg_level), val);
-
-	}
-	else
-	{
-	gtk_widget_hide (brg);
-	gtk_widget_hide (brg_level);
-	}
-
-    label_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac-label"));
-    label_display_blank_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac-label"));
-    label_dpms_sleep_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac-label"));
-    label_dpms_off_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac-label"));
-    label_brightness_level_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-ac-label"));
-    label_brightness_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac-label"));
-
-    update_label (label_inactivity_on_ac, inact_timeout, format_inactivity_value_cb);
-    update_label (label_display_blank_on_ac, on_ac_display_blank, format_dpms_value_cb);
-    update_label (label_dpms_sleep_on_ac, on_ac_dpms_sleep, format_dpms_value_cb);
-    update_label (label_dpms_off_on_ac, on_ac_dpms_off, format_dpms_value_cb);
-    update_label (label_brightness_level_on_ac, brg_level, format_brightness_percentage_cb);
-    update_label (label_brightness_inactivity_on_ac, brg, format_brightness_value_cb);
+    gtk_list_store_append(list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
+
+    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+      gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                          1, &list_value, -1);
+      if ( val == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
+        break;
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label1")));
+    gtk_widget_hide (lid);
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-plugged-in-header")));
+  }
+
+  /*
+   * Brightness on AC power
+   */
+  brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-ac"));
+  brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-ac"));
+  if ( has_lcd_brightness )
+  {
+    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, 9);
+    gtk_range_set_value (GTK_RANGE(brg), val);
+
+    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, 80);
+    gtk_range_set_value (GTK_RANGE (brg_level), val);
+  }
+  else
+  {
+    gtk_widget_hide (brg);
+    gtk_widget_hide (brg_level);
+  }
+
+  label_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac-label"));
+  label_display_blank_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac-label"));
+  label_dpms_sleep_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac-label"));
+  label_dpms_off_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac-label"));
+  label_brightness_level_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-ac-label"));
+  label_brightness_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac-label"));
+
+  update_label (label_inactivity_on_ac, inact_timeout, format_inactivity_value_cb);
+  update_label (label_display_blank_on_ac, on_ac_display_blank, format_dpms_value_cb);
+  update_label (label_dpms_sleep_on_ac, on_ac_dpms_sleep, format_dpms_value_cb);
+  update_label (label_dpms_off_on_ac, on_ac_dpms_off, format_dpms_value_cb);
+  update_label (label_brightness_level_on_ac, brg_level, format_brightness_percentage_cb);
+  update_label (label_brightness_inactivity_on_ac, brg, format_brightness_value_cb);
 }
 
 static void
@@ -1298,242 +1266,243 @@ xfpm_settings_general (XfconfChannel *channel, gboolean auth_suspend,
                        gboolean has_sleep_button, gboolean has_hibernate_button,
                        gboolean has_power_button, gboolean has_battery_button)
 {
-    GtkWidget *power;
-    GtkWidget *power_label;
-    GtkWidget *hibernate;
-    GtkWidget *hibernate_label;
-    GtkWidget *sleep_w;
-    GtkWidget *sleep_label;
-    GtkWidget *battery_w;
-    GtkWidget *battery_label;
-    GtkWidget *dpms;
-
-    guint  value;
-    guint list_value;
-    gboolean valid;
-    gboolean val;
-
-    GtkListStore *list_store;
-    GtkTreeIter iter;
-
-    dpms = GTK_WIDGET (gtk_builder_get_object (xml, "handle-dpms"));
-
-    /*
-     * Global dpms settings (enable/disable)
-     */
-    val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
-    gtk_switch_set_state (GTK_SWITCH (dpms), val);
-
-    /*
-     * Power button
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    power = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-combo"));
-    power_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-label"));
+  GtkWidget *power;
+  GtkWidget *power_label;
+  GtkWidget *hibernate;
+  GtkWidget *hibernate_label;
+  GtkWidget *sleep_w;
+  GtkWidget *sleep_label;
+  GtkWidget *battery_w;
+  GtkWidget *battery_label;
+  GtkWidget *dpms;
+
+  guint  value;
+  guint list_value;
+  gboolean valid;
+  gboolean val;
+
+  GtkListStore *list_store;
+  GtkTreeIter iter;
+
+  dpms = GTK_WIDGET (gtk_builder_get_object (xml, "handle-dpms"));
+
+  /*
+   * Global dpms settings (enable/disable)
+   */
+  val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
+  gtk_switch_set_state (GTK_SWITCH (dpms), val);
+
+  /*
+   * Power button
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  power = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-combo"));
+  power_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-label"));
+
+  if ( has_power_button )
+  {
+    gtk_combo_box_set_model (GTK_COMBO_BOX(power), GTK_TREE_MODEL(list_store));
+
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
 
-    if ( has_power_button )
+    if ( can_suspend && auth_suspend)
     {
-	gtk_combo_box_set_model (GTK_COMBO_BOX(power), GTK_TREE_MODEL(list_store));
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
-
-	if ( can_suspend && auth_suspend)
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-	}
-
-	if ( can_hibernate && auth_hibernate )
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-	}
-
-	if ( can_shutdown )
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
-	}
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
-
-	gtk_combo_box_set_active (GTK_COMBO_BOX (power), 0);
-
-	value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, XFPM_DO_NOTHING);
-	for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	      valid;
-	      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-	{
-	    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-				1, &list_value, -1);
-	    if ( value == list_value )
-	    {
-		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (power), &iter);
-		break;
-	    }
-	}
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
     }
-    else
+
+    if ( can_hibernate && auth_hibernate )
     {
-	gtk_widget_hide (power);
-	gtk_widget_hide (power_label);
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
     }
 
-    /*
-     * Hibernate button
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    hibernate = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-combo"));
-    hibernate_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-label"));
+    if ( can_shutdown )
+    {
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
+    }
+
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (power), 0);
+
+    value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, XFPM_DO_NOTHING);
+
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+      gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                          1, &list_value, -1);
+      if ( value == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (power), &iter);
+        break;
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (power);
+    gtk_widget_hide (power_label);
+  }
+
+  /*
+   * Hibernate button
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  hibernate = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-combo"));
+  hibernate_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-label"));
+
+  if (has_hibernate_button )
+  {
+    gtk_combo_box_set_model (GTK_COMBO_BOX(hibernate), GTK_TREE_MODEL(list_store));
+
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
 
-    if (has_hibernate_button )
+    if ( can_suspend && auth_suspend)
     {
-	gtk_combo_box_set_model (GTK_COMBO_BOX(hibernate), GTK_TREE_MODEL(list_store));
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
-
-	if ( can_suspend && auth_suspend)
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-	}
-
-	if ( can_hibernate && auth_hibernate )
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-	}
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
-
-	value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, XFPM_DO_NOTHING);
-
-	gtk_combo_box_set_active (GTK_COMBO_BOX (hibernate), 0);
-
-	for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	      valid;
-	      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-	{
-	    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-				1, &list_value, -1);
-	    if ( value == list_value )
-	    {
-		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (hibernate), &iter);
-		break;
-	    }
-	}
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
     }
-    else
+
+    if ( can_hibernate && auth_hibernate )
     {
-	gtk_widget_hide (hibernate);
-	gtk_widget_hide (hibernate_label);
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
     }
 
-    /*
-     * Sleep button
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    sleep_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-combo"));
-    sleep_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-label"));
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+
+    value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, XFPM_DO_NOTHING);
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (hibernate), 0);
+
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+      gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                          1, &list_value, -1);
+      if ( value == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (hibernate), &iter);
+        break;
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (hibernate);
+    gtk_widget_hide (hibernate_label);
+  }
+
+  /*
+   * Sleep button
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  sleep_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-combo"));
+  sleep_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-label"));
+
+  if ( has_sleep_button )
+  {
+    gtk_combo_box_set_model (GTK_COMBO_BOX(sleep_w), GTK_TREE_MODEL(list_store));
 
-    if ( has_sleep_button )
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
+
+    if ( can_suspend && auth_suspend )
     {
-	gtk_combo_box_set_model (GTK_COMBO_BOX(sleep_w), GTK_TREE_MODEL(list_store));
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
-
-	if ( can_suspend && auth_suspend )
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-	}
-
-	if ( can_hibernate && auth_hibernate)
-	{
-	    gtk_list_store_append (list_store, &iter);
-	    gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-	}
-
-	gtk_list_store_append (list_store, &iter);
-	gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
-
-	gtk_combo_box_set_active (GTK_COMBO_BOX (sleep_w), 0);
-
-	value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, XFPM_DO_NOTHING);
-	for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-	      valid;
-	      valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-	{
-	    gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-				1, &list_value, -1);
-	    if ( value == list_value )
-	    {
-		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (sleep_w), &iter);
-		break;
-	    }
-	}
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
     }
-    else
+
+    if ( can_hibernate && auth_hibernate)
     {
-	gtk_widget_hide (sleep_w);
-	gtk_widget_hide (sleep_label);
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
     }
 
-    /*
-     * Battery button
-     */
-    list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
-    battery_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-combo"));
-    battery_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-label"));
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (sleep_w), 0);
+
+    value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, XFPM_DO_NOTHING);
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+      gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                          1, &list_value, -1);
+      if ( value == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (sleep_w), &iter);
+        break;
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (sleep_w);
+    gtk_widget_hide (sleep_label);
+  }
+
+  /*
+   * Battery button
+   */
+  list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  battery_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-combo"));
+  battery_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-label"));
+
+  if ( has_battery_button )
+  {
+    gtk_combo_box_set_model (GTK_COMBO_BOX(battery_w), GTK_TREE_MODEL(list_store));
+
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
 
-    if ( has_battery_button )
+    if ( can_suspend && auth_suspend )
     {
-        gtk_combo_box_set_model (GTK_COMBO_BOX(battery_w), GTK_TREE_MODEL(list_store));
-
-        gtk_list_store_append (list_store, &iter);
-        gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
-
-        if ( can_suspend && auth_suspend )
-        {
-            gtk_list_store_append (list_store, &iter);
-            gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
-        }
-
-        if ( can_hibernate && auth_hibernate)
-        {
-            gtk_list_store_append (list_store, &iter);
-            gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
-        }
-
-        gtk_list_store_append (list_store, &iter);
-        gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
-
-        gtk_combo_box_set_active (GTK_COMBO_BOX (battery_w), 0);
-
-        value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, XFPM_DO_NOTHING);
-        for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
-              valid;
-              valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
-        {
-            gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
-                                1, &list_value, -1);
-            if ( value == list_value )
-            {
-                gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_w), &iter);
-                break;
-            }
-        }
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
     }
-    else
+
+    if ( can_hibernate && auth_hibernate)
     {
-        gtk_widget_hide (battery_w);
-        gtk_widget_hide (battery_label);
+      gtk_list_store_append (list_store, &iter);
+      gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
     }
+
+    gtk_list_store_append (list_store, &iter);
+    gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
+
+    gtk_combo_box_set_active (GTK_COMBO_BOX (battery_w), 0);
+
+    value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, XFPM_DO_NOTHING);
+    for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
+          valid;
+          valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
+    {
+      gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
+                          1, &list_value, -1);
+      if ( value == list_value )
+      {
+        gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_w), &iter);
+        break;
+      }
+    }
+  }
+  else
+  {
+    gtk_widget_hide (battery_w);
+    gtk_widget_hide (battery_label);
+  }
 }
 
 static void
@@ -1541,234 +1510,246 @@ xfpm_settings_advanced (XfconfChannel *channel, gboolean auth_suspend,
                         gboolean auth_hibernate, gboolean can_suspend,
                         gboolean can_hibernate, gboolean has_battery)
 {
-    guint val;
-    GtkWidget *critical_level;
-    GtkWidget *lock;
-    GtkWidget *label;
-
-    /*
-     * Critical battery level
-     */
-    critical_level = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-spin"));
-    if ( has_battery )
-    {
-	gtk_widget_set_tooltip_text (critical_level,
-				     _("When all the power sources of the computer reach this charge level"));
-
-	val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, 10);
-
-	if ( val > 20 || val < 1)
-	{
-	    g_critical ("Value %d if out of range for property %s\n", val, CRITICAL_POWER_LEVEL);
-	    gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), 10);
-	}
-	else
-	    gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), val);
-    }
-    else
-    {
-	label = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-label" ));
-	gtk_widget_hide (critical_level);
-	gtk_widget_hide (label);
-    }
+  guint val;
+  GtkWidget *critical_level;
+  GtkWidget *lock;
+  GtkWidget *label;
 
-    /*
-     * Lock screen for suspend/hibernate
-     */
-    lock = GTK_WIDGET (gtk_builder_get_object (xml, "lock-screen"));
+  /*
+   * Critical battery level
+   */
+  critical_level = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-spin"));
+  if ( has_battery )
+  {
+    gtk_widget_set_tooltip_text (critical_level,
+               _("When all the power sources of the computer reach this charge level"));
 
-    if ( !can_suspend && !can_hibernate )
-    {
-	gtk_widget_set_sensitive (lock, FALSE);
-	gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not supported"));
-    }
-    else if ( !auth_hibernate && !auth_suspend)
+    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, 10);
+
+    if ( val > 20 || val < 1)
     {
-	gtk_widget_set_sensitive (lock, FALSE);
-	gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not permitted"));
+      g_critical ("Value %d if out of range for property %s\n", val, CRITICAL_POWER_LEVEL);
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), 10);
     }
-
-    val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lock), val);
+    else
+      gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), val);
+  }
+  else
+  {
+    label = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-label" ));
+    gtk_widget_hide (critical_level);
+    gtk_widget_hide (label);
+  }
+
+  /*
+   * Lock screen for suspend/hibernate
+   */
+  lock = GTK_WIDGET (gtk_builder_get_object (xml, "lock-screen"));
+
+  if ( !can_suspend && !can_hibernate )
+  {
+    gtk_widget_set_sensitive (lock, FALSE);
+    gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not supported"));
+  }
+  else if ( !auth_hibernate && !auth_suspend)
+  {
+    gtk_widget_set_sensitive (lock, FALSE);
+    gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not permitted"));
+  }
+
+  val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lock), val);
 }
 
 /* Light Locker Integration */
 static gchar*
 get_light_locker_path (void)
 {
-    gchar** paths = NULL;
-    gchar* path = NULL;
-    unsigned int i = 0;
-
-    /* Check if executable in path */
-    paths = g_strsplit(g_getenv("PATH"), ":", 0);
-    for (i = 0; i < g_strv_length(paths); i++) {
-        path = g_strdup(g_build_filename(paths[i], "light-locker", NULL));
-        if (g_file_test(path, G_FILE_TEST_EXISTS))
-        {
-            break;
-        }
-        g_free(path);
-        path = NULL;
+  gchar** paths = NULL;
+  gchar* path = NULL;
+  unsigned int i = 0;
+
+  /* Check if executable is in path */
+  paths = g_strsplit (g_getenv ("PATH"), ":", 0);
+  for (i = 0; i < g_strv_length (paths); i++) {
+    path = g_strdup (g_build_filename (paths[i], "light-locker", NULL));
+    if (g_file_test (path, G_FILE_TEST_EXISTS))
+    {
+        break;
     }
-    g_strfreev(paths);
+    g_free (path);
+    path = NULL;
+  }
+  g_strfreev (paths);
 
-    return path;
+  return path;
 }
 
 gchar *
 format_light_locker_value_cb (gint value)
 {
-    gint min;
+  gint min;
 
-    if ( value <= 0 )
-        return g_strdup (_("Never"));
-    else if ( value < 60 )
-        return g_strdup_printf ("%d %s", value, _("seconds"));
+  if ( value <= 0 )
+    return g_strdup (_("Never"));
+  else if ( value < 60 )
+    return g_strdup_printf ("%d %s", value, _("seconds"));
+  else
+  {
+    min = value - 60;
+    if (min == 0)
+      return g_strdup_printf ("%d %s", min + 1, _("minute"));
     else
-    {
-        min = value - 60;
-        if (min == 0)
-            return g_strdup_printf ("%d %s", min + 1, _("minute"));
-        else
-            return g_strdup_printf ("%d %s", min + 1, _("minutes"));
-    }
+      return g_strdup_printf ("%d %s", min + 1, _("minutes"));
+  }
 }
 
 void
 light_locker_late_locking_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
 {
-    GVariant *variant;
-    gint      value = (gint)gtk_range_get_value (GTK_RANGE (widget));
+  GVariant *variant;
+  gint      value = (gint)gtk_range_get_value (GTK_RANGE (widget));
 
-    if (value > 60) {
-        value = ((value - 60) + 1) * 60;
-    }
+  if (value > 60) {
+    value = ((value - 60) + 1) * 60;
+  }
 
-    variant = g_variant_new_uint32 (value);
+  variant = g_variant_new_uint32 (value);
 
-    if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
-    {
-        g_critical ("Cannot set value for property lock-after-screensaver\n");
-    }
+  if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
+  {
+    g_critical ("Cannot set value for property lock-after-screensaver\n");
+  }
 
-    update_label (label_light_locker_late_locking_scale, widget, format_light_locker_value_cb);
+  update_label (label_light_locker_late_locking_scale, widget, format_light_locker_value_cb);
 }
 
 void
 light_locker_automatic_locking_changed_cb (GtkWidget *widget, XfconfChannel *channel)
 {
-    GVariant *variant;
-    gint      value;
-    gint      lock_after_screensaver;
-    gboolean  late_locking = FALSE;
-
-    value = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
-    gtk_widget_set_sensitive (light_locker_delay, value != 0);
-
-    if (value == 0)
-        lock_after_screensaver = 0;
-    else {
-        lock_after_screensaver = (gint)gtk_range_get_value (GTK_RANGE (light_locker_delay));
-        if (lock_after_screensaver > 60) {
-            lock_after_screensaver = (lock_after_screensaver - 60) * 60;
-        }
+  GVariant *variant;
+  gint      value;
+  gint      lock_after_screensaver;
+  gboolean  late_locking = FALSE;
+
+  value = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
+  gtk_widget_set_sensitive (light_locker_delay, value != 0);
+
+  if (value == 0)
+    lock_after_screensaver = 0;
+  else {
+    lock_after_screensaver = (gint)gtk_range_get_value (GTK_RANGE (light_locker_delay));
+    if (lock_after_screensaver > 60) {
+        lock_after_screensaver = (lock_after_screensaver - 60) * 60;
     }
+  }
 
-    if (value == 2)
-        late_locking = TRUE;
+  if (value == 2)
+    late_locking = TRUE;
 
-    variant = g_variant_new_uint32 (lock_after_screensaver);
-    if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
-        g_critical ("Cannot set value for property lock-after-screensaver\n");
+  variant = g_variant_new_uint32 (lock_after_screensaver);
+  if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
+    g_critical ("Cannot set value for property lock-after-screensaver\n");
 
-    variant = g_variant_new_boolean (late_locking);
-    if (!g_settings_set_value (light_locker_settings, "late-locking", variant))
-        g_critical ("Cannot set value for property late-locking\n");
+  variant = g_variant_new_boolean (late_locking);
+  if (!g_settings_set_value (light_locker_settings, "late-locking", variant))
+    g_critical ("Cannot set value for property late-locking\n");
 }
 
 static void xfpm_settings_light_locker (XfconfChannel *channel,
                                         gboolean auth_suspend, gboolean auth_hibernate,
                                         gboolean can_suspend, gboolean can_hibernate)
 {
-    GSettingsSchemaSource *schema_source;
-    GSettingsSchema       *schema;
-    GVariant              *variant;
-    gboolean               late_locking, lock_on_suspend, xfpm_lock_on_suspend;
-    guint32                lock_after_screensaver;
-    GtkWidget             *security_frame;
-
-    /* Collect the Light Locker widgets */
-    light_locker_tab = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-vbox1"));
-    light_locker_autolock = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-automatic-locking-combo"));
-    light_locker_delay = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale"));
-    light_locker_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-suspend"));
-
-    if ( !can_suspend && !can_hibernate )
+  GSettingsSchemaSource *schema_source;
+  GSettingsSchema       *schema;
+  GVariant              *variant;
+  gboolean               late_locking, lock_on_suspend, xfpm_lock_on_suspend;
+  guint32                lock_after_screensaver;
+  GtkWidget             *security_frame;
+
+  /* Collect the Light Locker widgets */
+  light_locker_tab = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-vbox1"));
+  light_locker_autolock = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-automatic-locking-combo"));
+  light_locker_delay = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale"));
+  light_locker_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-suspend"));
+
+  if ( !can_suspend && !can_hibernate )
+  {
+    gtk_widget_set_sensitive (light_locker_sleep, FALSE);
+    gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not supported"));
+  }
+  else if ( !auth_hibernate && !auth_suspend)
+  {
+    gtk_widget_set_sensitive (light_locker_sleep, FALSE);
+    gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not permitted"));
+  }
+
+  schema_source = g_settings_schema_source_get_default();
+  schema = g_settings_schema_source_lookup (schema_source, "apps.light-locker", TRUE);
+
+  if (schema != NULL && get_light_locker_path() != NULL)
+  {
+    security_frame = GTK_WIDGET (gtk_builder_get_object (xml, "security-frame"));
+    gtk_widget_hide (security_frame);
+    /* Load the settings (Light Locker compiled with GSettings backend required) */
+    light_locker_settings = g_settings_new ("apps.light-locker");
+
+    variant = g_settings_get_value (light_locker_settings, "late-locking");
+    late_locking = g_variant_get_boolean (variant);
+
+    variant = g_settings_get_value (light_locker_settings, "lock-on-suspend");
+    lock_on_suspend = g_variant_get_boolean (variant);
+    xfpm_lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
+    if (lock_on_suspend != xfpm_lock_on_suspend)
     {
-        gtk_widget_set_sensitive (light_locker_sleep, FALSE);
-        gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not supported"));
+      variant = g_variant_new_boolean (xfpm_lock_on_suspend);
+      if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
+      {
+        g_critical ("Cannot set value for property lock-on-suspend\n");
+      }
+      lock_on_suspend = xfpm_lock_on_suspend;
     }
-    else if ( !auth_hibernate && !auth_suspend)
+
+    variant = g_settings_get_value (light_locker_settings, "lock-after-screensaver");
+    lock_after_screensaver = g_variant_get_uint32 (variant);
+
+    gtk_widget_set_sensitive (light_locker_delay, lock_after_screensaver != 0);
+
+    if (lock_after_screensaver > 60)
     {
-        gtk_widget_set_sensitive (light_locker_sleep, FALSE);
-        gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not permitted"));
+      lock_after_screensaver = (lock_after_screensaver / 60) + 60;
     }
 
-    schema_source = g_settings_schema_source_get_default();
-    schema = g_settings_schema_source_lookup (schema_source, "apps.light-locker", TRUE);
-
-    if (schema != NULL && get_light_locker_path() != NULL) {
-        security_frame = GTK_WIDGET (gtk_builder_get_object (xml, "security-frame"));
-        gtk_widget_hide(security_frame);
-        /* Load the settings (Light Locker compiled with GSettings backend required) */
-        light_locker_settings = g_settings_new ("apps.light-locker");
-
-        variant = g_settings_get_value (light_locker_settings, "late-locking");
-        late_locking = g_variant_get_boolean (variant);
-
-        variant = g_settings_get_value (light_locker_settings, "lock-on-suspend");
-        lock_on_suspend = g_variant_get_boolean (variant);
-        xfpm_lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
-        if (lock_on_suspend != xfpm_lock_on_suspend) {
-            variant = g_variant_new_boolean (xfpm_lock_on_suspend);
-            if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant)) {
-                g_critical ("Cannot set value for property lock-on-suspend\n");
-            }
-            lock_on_suspend = xfpm_lock_on_suspend;
-        }
-
-        variant = g_settings_get_value (light_locker_settings, "lock-after-screensaver");
-        lock_after_screensaver = g_variant_get_uint32 (variant);
-
-        gtk_widget_set_sensitive (light_locker_delay, lock_after_screensaver != 0);
-
-        if (lock_after_screensaver > 60) {
-            lock_after_screensaver = (lock_after_screensaver / 60) + 60;
-        }
-
-        /* Apply the settings */
-        if (lock_after_screensaver == 0) {
-            gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 0);
-        } else {
-            if (!late_locking) {
-                gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 1);
-            } else {
-                gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 2);
-            }
-            gtk_range_set_value (GTK_RANGE(light_locker_delay), lock_after_screensaver);
-        }
-
-        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(light_locker_sleep), lock_on_suspend);
-
-        g_settings_schema_unref (schema);
-    } else {
-        XFPM_DEBUG ("Schema \"apps.light-locker\" not found. Not configuring Light Locker.");
-        gtk_widget_hide (light_locker_tab);
+    /* Apply the settings */
+    if (lock_after_screensaver == 0)
+    {
+      gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 0);
     }
-
-    label_light_locker_late_locking_scale = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale-label"));
-    update_label (label_light_locker_late_locking_scale, light_locker_delay, format_light_locker_value_cb);
+    else
+    {
+      if (!late_locking)
+      {
+        gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 1);
+      }
+      else
+      {
+        gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 2);
+      }
+      gtk_range_set_value (GTK_RANGE(light_locker_delay), lock_after_screensaver);
+    }
+
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(light_locker_sleep), lock_on_suspend);
+
+    g_settings_schema_unref (schema);
+  }
+  else
+  {
+    XFPM_DEBUG ("Schema \"apps.light-locker\" not found. Not configuring Light Locker.");
+    gtk_widget_hide (light_locker_tab);
+  }
+
+  label_light_locker_late_locking_scale = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale-label"));
+  update_label (label_light_locker_late_locking_scale, light_locker_delay, format_light_locker_value_cb);
 }
 /* END Light Locker Integration */
 
@@ -1776,74 +1757,76 @@ static void xfpm_settings_light_locker (XfconfChannel *channel,
 static GtkTreeIter*
 find_device_in_tree (const gchar *object_path)
 {
-    GtkTreeModel *model;
-    GtkTreeIter iter;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
 
-    if ( !sideview )
-        return NULL;
+  if ( !sideview )
+    return NULL;
 
-    model = gtk_tree_view_get_model(GTK_TREE_VIEW(sideview));
+  model = gtk_tree_view_get_model(GTK_TREE_VIEW(sideview));
 
-    if (!model)
-        return NULL;
+  if (!model)
+    return NULL;
 
-    if(gtk_tree_model_get_iter_first(model, &iter)) {
-        do {
-            gchar *path = NULL;
-            gtk_tree_model_get(model, &iter, COL_SIDEBAR_OBJECT_PATH, &path, -1);
+  if(gtk_tree_model_get_iter_first(model, &iter))
+  {
+    do {
+      gchar *path = NULL;
+      gtk_tree_model_get(model, &iter, COL_SIDEBAR_OBJECT_PATH, &path, -1);
 
-            if(g_strcmp0(path, object_path) == 0) {
-                g_free(path);
-                return gtk_tree_iter_copy(&iter);
-            }
+      if(g_strcmp0(path, object_path) == 0)
+      {
+        g_free(path);
+        return gtk_tree_iter_copy(&iter);
+      }
 
-            g_free(path);
-        } while(gtk_tree_model_iter_next(model, &iter));
-    }
+      g_free (path);
+    } while (gtk_tree_model_iter_next(model, &iter));
+  }
 
-    return NULL;
+  return NULL;
 }
 
 /* Call gtk_tree_iter_free when done with the tree iter */
 static GtkTreeIter*
 find_device_info_name_in_tree (GtkTreeView *view, const gchar *device_info_name)
 {
-    GtkTreeModel *model;
-    GtkTreeIter iter;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
 
-    if ( !view )
-        return NULL;
+  if ( !view )
+    return NULL;
 
-    model = gtk_tree_view_get_model(view);
+  model = gtk_tree_view_get_model (view);
 
-    if (!model)
-        return NULL;
+  if (!model)
+    return NULL;
 
-    if(gtk_tree_model_get_iter_first(model, &iter)) {
-        do {
-            gchar *name = NULL;
-            gtk_tree_model_get(model, &iter, XFPM_DEVICE_INFO_NAME, &name, -1);
+  if (gtk_tree_model_get_iter_first (model, &iter)) {
+    do {
+      gchar *name = NULL;
+      gtk_tree_model_get (model, &iter, XFPM_DEVICE_INFO_NAME, &name, -1);
 
-            if(g_strcmp0(name, device_info_name) == 0) {
-                g_free(name);
-                return gtk_tree_iter_copy(&iter);
-            }
+      if(g_strcmp0 (name, device_info_name) == 0) {
+          g_free (name);
+          return gtk_tree_iter_copy (&iter);
+      }
 
-            g_free(name);
-        } while(gtk_tree_model_iter_next(model, &iter));
-    }
+      g_free (name);
+    } while(gtk_tree_model_iter_next(model, &iter));
+  }
 
-    return NULL;
+  return NULL;
 }
 
 static gchar *
 xfpm_info_get_energy_property (gdouble energy, const gchar *unit)
 {
-    gchar *val = NULL;
+  gchar *val = NULL;
 
-    val = g_strdup_printf ("%.1f %s", energy, unit);
+  val = g_strdup_printf ("%.1f %s", energy, unit);
 
-    return val;
+  return val;
 }
 
 static void
@@ -1852,232 +1835,232 @@ update_device_info_value_for_name (GtkTreeView *view,
                                    const gchar *name,
                                    const gchar *value)
 {
-    GtkTreeIter *iter;
-
-    g_return_if_fail (GTK_IS_TREE_VIEW(view));
-    g_return_if_fail (GTK_IS_LIST_STORE(list_store));
-    g_return_if_fail (name != NULL);
-    /* Value can be NULL */
-
-    DBG ("updating  name %s with value %s", name, value);
-
-    iter = find_device_info_name_in_tree (view, name);
-    if (iter == NULL)
-    {
-        /* The row doesn't exist yet, add it */
-        GtkTreeIter new_iter;
-        gtk_list_store_append (list_store, &new_iter);
-        iter = gtk_tree_iter_copy (&new_iter);
-    }
-
-    if (value != NULL)
-    {
-        gtk_list_store_set (list_store, iter,
-                            XFPM_DEVICE_INFO_NAME, name,
-                            XFPM_DEVICE_INFO_VALUE, value,
-                            -1);
-    }
-    else
-    {
-        /* The value no longer applies, remove the row */
-        gtk_list_store_remove (list_store, iter);
-    }
+  GtkTreeIter *iter;
+
+  g_return_if_fail (GTK_IS_TREE_VIEW(view));
+  g_return_if_fail (GTK_IS_LIST_STORE(list_store));
+  g_return_if_fail (name != NULL);
+  /* Value can be NULL */
+
+  DBG ("updating  name %s with value %s", name, value);
+
+  iter = find_device_info_name_in_tree (view, name);
+  if (iter == NULL)
+  {
+    /* The row doesn't exist yet, add it */
+    GtkTreeIter new_iter;
+    gtk_list_store_append (list_store, &new_iter);
+    iter = gtk_tree_iter_copy (&new_iter);
+  }
+
+  if (value != NULL)
+  {
+    gtk_list_store_set (list_store, iter,
+                        XFPM_DEVICE_INFO_NAME, name,
+                        XFPM_DEVICE_INFO_VALUE, value,
+                        -1);
+  }
+  else
+  {
+    /* The value no longer applies, remove the row */
+    gtk_list_store_remove (list_store, iter);
+  }
 
-    gtk_tree_iter_free (iter);
+  gtk_tree_iter_free (iter);
 }
 
 static void
 update_sideview_icon (UpDevice *device)
 {
-    GtkListStore *list_store;
-    GtkTreeIter *iter;
-    GdkPixbuf *pix;
-    guint type = 0;
-    gchar *name = NULL, *icon_name = NULL, *model = NULL, *vendor = NULL;
-    const gchar *object_path = up_device_get_object_path(device);
+  GtkListStore *list_store;
+  GtkTreeIter *iter;
+  GdkPixbuf *pix;
+  guint type = 0;
+  gchar *name = NULL, *icon_name = NULL, *model = NULL, *vendor = NULL;
+  const gchar *object_path = up_device_get_object_path(device);
 
-    list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
+  list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
 
-    TRACE("entering for %s", object_path);
+  TRACE("entering for %s", object_path);
 
-    iter = find_device_in_tree (object_path);
+  iter = find_device_in_tree (object_path);
 
-    /* quit if device doesn't exist in the sidebar */
-    if (!iter)
-        return;
+  /* quit if device doesn't exist in the sidebar */
+  if (!iter)
+    return;
 
-    /* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
-    g_object_get (device,
-                  "kind", &type,
-                  "vendor", &vendor,
-                  "model", &model,
-                  NULL);
+  /* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
+  g_object_get (device,
+                "kind", &type,
+                "vendor", &vendor,
+                "model", &model,
+                NULL);
 
 
-    name = get_device_description (upower, device);
-    icon_name = get_device_icon_name (upower, device);
+  name = get_device_description (upower, device);
+  icon_name = get_device_icon_name (upower, device);
 
-    pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
-                                    icon_name,
-                                    48,
-                                    GTK_ICON_LOOKUP_USE_BUILTIN,
-                                    NULL);
+  pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
+                                  icon_name,
+                                  48,
+                                  GTK_ICON_LOOKUP_USE_BUILTIN,
+                                  NULL);
 
-    gtk_list_store_set (list_store, iter,
-                        COL_SIDEBAR_ICON, pix,
-                        COL_SIDEBAR_NAME, name,
-                        -1);
+  gtk_list_store_set (list_store, iter,
+                      COL_SIDEBAR_ICON, pix,
+                      COL_SIDEBAR_NAME, name,
+                      -1);
 
-    if ( pix )
-        g_object_unref (pix);
+  if ( pix )
+    g_object_unref (pix);
 
-    g_free (name);
-    g_free (icon_name);
+  g_free (name);
+  g_free (icon_name);
 
-    gtk_tree_iter_free (iter);
+  gtk_tree_iter_free (iter);
 }
 
 static void
 update_device_details (UpDevice *device)
 {
-    GtkTreeView *view;
-    GtkListStore *list_store;
-    GtkTreeIter *sideview_iter;
-    gchar *str;
-    guint type = 0, tech = 0;
-    gdouble energy_full_design = -1.0, energy_full = -1.0, energy_empty = -1.0, voltage = -1.0, percent = -1.0;
-    gboolean p_supply = FALSE;
-    gchar *model = NULL, *vendor = NULL, *serial = NULL;
-    const gchar *battery_type = NULL;
-    const gchar *object_path = up_device_get_object_path(device);
-
-    TRACE("entering for %s", object_path);
-
-    sideview_iter = find_device_in_tree (object_path);
-
-    /* quit if device doesn't exist in the sidebar */
-    if (sideview_iter == NULL)
-        return;
-
-    gtk_tree_model_get (gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)), sideview_iter,
-                        COL_SIDEBAR_VIEW, &view,
-                        -1);
+  GtkTreeView *view;
+  GtkListStore *list_store;
+  GtkTreeIter *sideview_iter;
+  gchar *str;
+  guint type = 0, tech = 0;
+  gdouble energy_full_design = -1.0, energy_full = -1.0, energy_empty = -1.0, voltage = -1.0, percent = -1.0;
+  gboolean p_supply = FALSE;
+  gchar *model = NULL, *vendor = NULL, *serial = NULL;
+  const gchar *battery_type = NULL;
+  const gchar *object_path = up_device_get_object_path(device);
+
+  TRACE("entering for %s", object_path);
+
+  sideview_iter = find_device_in_tree (object_path);
+
+  /* quit if device doesn't exist in the sidebar */
+  if (sideview_iter == NULL)
+    return;
 
-    list_store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
-
-    /**
-     * Add/Update Device information:
-     **/
-    /*Device*/
-    update_device_info_value_for_name (view,
-                                      list_store,
-                                      _("Device"),
-                                      g_str_has_prefix (object_path, UPOWER_PATH_DEVICE) ? object_path + strlen (UPOWER_PATH_DEVICE) : object_path);
-
-    /*Type*/
-    /* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
-    g_object_get (device,
-                  "kind", &type,
-                  "power-supply", &p_supply,
-                  "model", &model,
-                  "vendor", &vendor,
-                  "serial", &serial,
-                  "technology", &tech,
-                  "energy-full-design", &energy_full_design,
-                  "energy-full", &energy_full,
-                  "energy-empty", &energy_empty,
-                  "voltage", &voltage,
-                  "percentage", &percent,
-                  NULL);
-
-    if (type != UP_DEVICE_KIND_UNKNOWN)
-    {
-        battery_type = xfpm_power_translate_device_type (type);
-        update_device_info_value_for_name (view, list_store, _("Type"), battery_type);
-    }
+  gtk_tree_model_get (gtk_tree_view_get_model (GTK_TREE_VIEW(sideview)), sideview_iter,
+                      COL_SIDEBAR_VIEW, &view,
+                      -1);
+
+  list_store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
+
+  /**
+   * Add/Update Device information:
+   **/
+  /*Device*/
+  update_device_info_value_for_name (view,
+                                    list_store,
+                                    _("Device"),
+                                    g_str_has_prefix (object_path, UPOWER_PATH_DEVICE) ? object_path + strlen (UPOWER_PATH_DEVICE) : object_path);
+
+  /*Type*/
+  /* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
+  g_object_get (device,
+                "kind", &type,
+                "power-supply", &p_supply,
+                "model", &model,
+                "vendor", &vendor,
+                "serial", &serial,
+                "technology", &tech,
+                "energy-full-design", &energy_full_design,
+                "energy-full", &energy_full,
+                "energy-empty", &energy_empty,
+                "voltage", &voltage,
+                "percentage", &percent,
+                NULL);
+
+  if (type != UP_DEVICE_KIND_UNKNOWN)
+  {
+    battery_type = xfpm_power_translate_device_type (type);
+    update_device_info_value_for_name (view, list_store, _("Type"), battery_type);
+  }
 
-    update_device_info_value_for_name (view,
-                                       list_store,
-                                       _("PowerSupply"),
-                                       p_supply == TRUE ? _("True") : _("False"));
+  update_device_info_value_for_name (view,
+                                     list_store,
+                                     _("PowerSupply"),
+                                     p_supply == TRUE ? _("True") : _("False"));
 
-    if ( type != UP_DEVICE_KIND_LINE_POWER )
+  if ( type != UP_DEVICE_KIND_LINE_POWER )
+  {
+    /*Model*/
+    if (model && strlen (model) > 0)
     {
-        /*Model*/
-        if (model && strlen (model) > 0)
-        {
-            update_device_info_value_for_name (view, list_store, _("Model"), model);
-        }
+      update_device_info_value_for_name (view, list_store, _("Model"), model);
+    }
 
-        update_device_info_value_for_name (view, list_store, _("Technology"), xfpm_power_translate_technology (tech));
+    update_device_info_value_for_name (view, list_store, _("Technology"), xfpm_power_translate_technology (tech));
 
-        /*Percentage*/
-        if (percent >= 0)
-        {
-            str = g_strdup_printf("%d%%", (guint) percent);
+    /*Percentage*/
+    if (percent >= 0)
+    {
+      str = g_strdup_printf("%d%%", (guint) percent);
 
-            update_device_info_value_for_name (view, list_store, _("Current charge"), str);
+      update_device_info_value_for_name (view, list_store, _("Current charge"), str);
 
-            g_free(str);
-        }
+      g_free(str);
+    }
 
-        if (energy_full_design > 0)
-        {
-            /* TRANSLATORS: Unit here is Watt hour*/
-            str = xfpm_info_get_energy_property (energy_full_design, _("Wh"));
+    if (energy_full_design > 0)
+    {
+      /* TRANSLATORS: Unit here is Watt hour*/
+      str = xfpm_info_get_energy_property (energy_full_design, _("Wh"));
 
-            update_device_info_value_for_name (view, list_store, _("Fully charged (design)"), str);
+      update_device_info_value_for_name (view, list_store, _("Fully charged (design)"), str);
 
-            g_free (str);
-        }
+      g_free (str);
+    }
 
-        if (energy_full > 0)
-        {
-            gchar *str2;
+    if (energy_full > 0)
+    {
+      gchar *str2;
 
-            /* TRANSLATORS: Unit here is Watt hour*/
-            str = xfpm_info_get_energy_property (energy_full, _("Wh"));
-            str2 = g_strdup_printf ("%s (%d%%)", str, (guint) (energy_full / energy_full_design *100));
+      /* TRANSLATORS: Unit here is Watt hour*/
+      str = xfpm_info_get_energy_property (energy_full, _("Wh"));
+      str2 = g_strdup_printf ("%s (%d%%)", str, (guint) (energy_full / energy_full_design *100));
 
-            update_device_info_value_for_name (view, list_store, _("Fully charged"), str2);
+      update_device_info_value_for_name (view, list_store, _("Fully charged"), str2);
 
-            g_free (str);
-            g_free (str2);
-        }
+      g_free (str);
+      g_free (str2);
+    }
 
-        if (energy_empty > 0)
-        {
-            /* TRANSLATORS: Unit here is Watt hour*/
-            str = xfpm_info_get_energy_property (energy_empty, _("Wh"));
+    if (energy_empty > 0)
+    {
+      /* TRANSLATORS: Unit here is Watt hour*/
+      str = xfpm_info_get_energy_property (energy_empty, _("Wh"));
 
-            update_device_info_value_for_name (view, list_store, _("Energy empty"), str);
+      update_device_info_value_for_name (view, list_store, _("Energy empty"), str);
 
-            g_free (str);
-        }
+      g_free (str);
+    }
 
-        if (voltage > 0)
-        {
-            /* TRANSLATORS: Unit here is Volt*/
-            str = xfpm_info_get_energy_property (voltage, _("V"));
+    if (voltage > 0)
+    {
+      /* TRANSLATORS: Unit here is Volt*/
+      str = xfpm_info_get_energy_property (voltage, _("V"));
 
-            update_device_info_value_for_name (view, list_store, _("Voltage"), str);
+      update_device_info_value_for_name (view, list_store, _("Voltage"), str);
 
-            g_free (str);
-        }
+      g_free (str);
+    }
 
-        if (vendor && strlen (vendor) > 0)
-        {
-            update_device_info_value_for_name (view, list_store, _("Vendor"), vendor);
-        }
+    if (vendor && strlen (vendor) > 0)
+    {
+      update_device_info_value_for_name (view, list_store, _("Vendor"), vendor);
+    }
 
-        if (serial && strlen (serial) > 0)
-        {
-            update_device_info_value_for_name (view, list_store, _("Serial"), serial);
-        }
+    if (serial && strlen (serial) > 0)
+    {
+      update_device_info_value_for_name (view, list_store, _("Serial"), serial);
     }
+  }
 
-    update_sideview_icon (device);
-    gtk_widget_show_all (GTK_WIDGET(view));
+  update_sideview_icon (device);
+  gtk_widget_show_all (GTK_WIDGET(view));
 }
 
 static void
@@ -2089,222 +2072,222 @@ device_changed_cb (UpDevice *device, GParamSpec *pspec, gpointer user_data)
 static void
 add_device (UpDevice *device)
 {
-    GtkTreeIter iter, *device_iter;
-    GtkListStore *sideview_store, *devices_store;
-    GtkTreeViewColumn *col;
-    GtkCellRenderer *renderer;
-    GtkWidget *frame, *view;
-    const gchar *object_path = up_device_get_object_path(device);
-    gulong signal_id;
-    guint index;
-    static gboolean first_run = TRUE;
-
-    TRACE("entering for %s", object_path);
-
-    /* don't add the same device twice */
-    device_iter = find_device_in_tree (object_path);
-    if (device_iter)
-    {
-        gtk_tree_iter_free (device_iter);
-        return;
-    }
-
-    /* Make sure the devices tab is shown */
-    gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
-
-    signal_id = g_signal_connect (device, "notify", G_CALLBACK (device_changed_cb), NULL);
-
-    sideview_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
-
-    index = gtk_notebook_get_n_pages (GTK_NOTEBOOK (device_details_notebook));
-
-    /* Create the page that the update_device_details will update/replace */
-    frame = gtk_frame_new (NULL);
-    view = gtk_tree_view_new ();
-    gtk_container_add (GTK_CONTAINER (frame), view);
-    gtk_widget_show_all (frame);
-    gtk_notebook_append_page (GTK_NOTEBOOK (device_details_notebook), frame, NULL);
-    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
-
-    /* Create the list store that the devices view will display */
-    devices_store = gtk_list_store_new (XFPM_DEVICE_INFO_LAST, G_TYPE_STRING, G_TYPE_STRING);
-    gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (devices_store));
-
-    /* Create the headers for this item in the device details tab */
-    renderer = gtk_cell_renderer_text_new ();
-
-    /*Device Attribute*/
-    col = gtk_tree_view_column_new();
-    gtk_tree_view_column_pack_start (col, renderer, FALSE);
-    gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_NAME, NULL);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
-
-    /*Device Attribute Value*/
-    col = gtk_tree_view_column_new();
-    gtk_tree_view_column_pack_start (col, renderer, FALSE);
-    gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_VALUE, NULL);
-
-    gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
-
-    /* Add the new device to the sidebar */
-    gtk_list_store_append (sideview_store, &iter);
-    gtk_list_store_set (sideview_store, &iter,
-                        COL_SIDEBAR_INT, index,
-                        COL_SIDEBAR_BATTERY_DEVICE, device,
-                        COL_SIDEBAR_OBJECT_PATH, object_path,
-                        COL_SIDEBAR_SIGNAL_ID, signal_id,
-                        COL_SIDEBAR_VIEW, view,
-                        -1);
-
-    /* Add the icon and description for the device */
-    update_device_details (device);
-
-    /* See if we're to select this device, for it to be selected,
-     * the starting_device_id must be unset and the this is the first
-     * time add_device is called (i.e. select the first device) or
-     * our current device matches starting_device_id. */
-    if ((starting_device_id == NULL && first_run == TRUE) ||
-        (g_strcmp0 (object_path, starting_device_id) == 0))
-    {
-	GtkTreeSelection *selection;
-
-	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
-
-	gtk_tree_selection_select_iter (selection, &iter);
-	view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
-    }
-
-    first_run = FALSE;
+  GtkTreeIter iter, *device_iter;
+  GtkListStore *sideview_store, *devices_store;
+  GtkTreeViewColumn *col;
+  GtkCellRenderer *renderer;
+  GtkWidget *frame, *view;
+  const gchar *object_path = up_device_get_object_path(device);
+  gulong signal_id;
+  guint index;
+  static gboolean first_run = TRUE;
+
+  TRACE("entering for %s", object_path);
+
+  /* don't add the same device twice */
+  device_iter = find_device_in_tree (object_path);
+  if (device_iter)
+  {
+    gtk_tree_iter_free (device_iter);
+    return;
+  }
+
+  /* Make sure the devices tab is shown */
+  gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
+
+  signal_id = g_signal_connect (device, "notify", G_CALLBACK (device_changed_cb), NULL);
+
+  sideview_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
+
+  index = gtk_notebook_get_n_pages (GTK_NOTEBOOK (device_details_notebook));
+
+  /* Create the page that the update_device_details will update/replace */
+  frame = gtk_frame_new (NULL);
+  view = gtk_tree_view_new ();
+  gtk_container_add (GTK_CONTAINER (frame), view);
+  gtk_widget_show_all (frame);
+  gtk_notebook_append_page (GTK_NOTEBOOK (device_details_notebook), frame, NULL);
+  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
+
+  /* Create the list store that the devices view will display */
+  devices_store = gtk_list_store_new (XFPM_DEVICE_INFO_LAST, G_TYPE_STRING, G_TYPE_STRING);
+  gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (devices_store));
+
+  /* Create the headers for this item in the device details tab */
+  renderer = gtk_cell_renderer_text_new ();
+
+  /*Device Attribute*/
+  col = gtk_tree_view_column_new();
+  gtk_tree_view_column_pack_start (col, renderer, FALSE);
+  gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_NAME, NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
+
+  /*Device Attribute Value*/
+  col = gtk_tree_view_column_new();
+  gtk_tree_view_column_pack_start (col, renderer, FALSE);
+  gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_VALUE, NULL);
+
+  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
+
+  /* Add the new device to the sidebar */
+  gtk_list_store_append (sideview_store, &iter);
+  gtk_list_store_set (sideview_store, &iter,
+                      COL_SIDEBAR_INT, index,
+                      COL_SIDEBAR_BATTERY_DEVICE, device,
+                      COL_SIDEBAR_OBJECT_PATH, object_path,
+                      COL_SIDEBAR_SIGNAL_ID, signal_id,
+                      COL_SIDEBAR_VIEW, view,
+                      -1);
+
+  /* Add the icon and description for the device */
+  update_device_details (device);
+
+  /* See if we're to select this device, for it to be selected,
+   * the starting_device_id must be unset and the this is the first
+   * time add_device is called (i.e. select the first device) or
+   * our current device matches starting_device_id. */
+  if ((starting_device_id == NULL && first_run == TRUE) ||
+      (g_strcmp0 (object_path, starting_device_id) == 0))
+  {
+    GtkTreeSelection *selection;
+
+    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
+
+    gtk_tree_selection_select_iter (selection, &iter);
+    view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
+  }
+
+  first_run = FALSE;
 }
 
 static void
 remove_device (const gchar *object_path)
 {
-    GtkTreeIter *iter;
-    GtkListStore *list_store;
-    gulong signal_id;
-    UpDevice *device;
+  GtkTreeIter *iter;
+  GtkListStore *list_store;
+  gulong signal_id;
+  UpDevice *device;
 
-    TRACE("entering for %s", object_path);
+  TRACE("entering for %s", object_path);
 
-    iter = find_device_in_tree (object_path);
+  iter = find_device_in_tree (object_path);
 
-    if (iter == NULL)
-        return;
+  if (iter == NULL)
+    return;
 
-    list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)));
+  list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)));
 
-    gtk_tree_model_get (GTK_TREE_MODEL(list_store), iter,
-                        COL_SIDEBAR_SIGNAL_ID, &signal_id,
-                        COL_SIDEBAR_BATTERY_DEVICE, &device,
-                        -1);
+  gtk_tree_model_get (GTK_TREE_MODEL(list_store), iter,
+                      COL_SIDEBAR_SIGNAL_ID, &signal_id,
+                      COL_SIDEBAR_BATTERY_DEVICE, &device,
+                      -1);
 
-    gtk_list_store_remove (list_store, iter);
+  gtk_list_store_remove (list_store, iter);
 
-    if (device)
-        g_signal_handler_disconnect (device, signal_id);
+  if (device)
+    g_signal_handler_disconnect (device, signal_id);
 
-    /* If there are no devices left, hide the devices tab */
-    if(!gtk_tree_model_get_iter_first (GTK_TREE_MODEL(list_store), iter))
-        gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
+  /* If there are no devices left, hide the devices tab */
+  if(!gtk_tree_model_get_iter_first (GTK_TREE_MODEL(list_store), iter))
+    gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
 }
 
 static void
 device_added_cb (UpClient *upclient, UpDevice *device, gpointer user_data)
 {
-    add_device (device);
+  add_device (device);
 }
 
 static void
 device_removed_cb (UpClient *upclient, const gchar *object_path, gpointer user_data)
 {
-    remove_device (object_path);
+  remove_device (object_path);
 }
 
 static void
 add_all_devices (void)
 {
-    GPtrArray *array = NULL;
-    guint i;
+  GPtrArray *array = NULL;
+  guint i;
 
 #if UP_CHECK_VERSION(0, 99, 8)
-    array = up_client_get_devices2 (upower);
+  array = up_client_get_devices2 (upower);
 #else
-    array = up_client_get_devices (upower);
+  array = up_client_get_devices (upower);
 #endif
 
-    if ( array )
+  if ( array )
+  {
+    for ( i = 0; i < array->len; i++)
     {
-        for ( i = 0; i < array->len; i++)
-        {
-            UpDevice *device = g_ptr_array_index (array, i);
+      UpDevice *device = g_ptr_array_index (array, i);
 
-            add_device (device);
-        }
-        g_ptr_array_free (array, TRUE);
+      add_device (device);
     }
+    g_ptr_array_free (array, TRUE);
+  }
 }
 
 static void
 settings_create_devices_list (void)
 {
-    upower = up_client_new ();
+  upower = up_client_new ();
 
-    g_signal_connect (upower, "device-added", G_CALLBACK (device_added_cb), NULL);
-    g_signal_connect (upower, "device-removed", G_CALLBACK (device_removed_cb), NULL);
+  g_signal_connect (upower, "device-added", G_CALLBACK (device_added_cb), NULL);
+  g_signal_connect (upower, "device-removed", G_CALLBACK (device_removed_cb), NULL);
 
-    add_all_devices ();
+  add_all_devices ();
 }
 
 static void
 view_cursor_changed_cb (GtkTreeView *view, gpointer *user_data)
 {
-    GtkTreeSelection *sel;
-    GtkTreeModel     *model;
-    GtkTreeIter       selected_row;
-    gint int_data = 0;
+  GtkTreeSelection *sel;
+  GtkTreeModel     *model;
+  GtkTreeIter       selected_row;
+  gint int_data = 0;
 
-    sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
 
-    if ( !gtk_tree_selection_get_selected (sel, &model, &selected_row))
-	return;
+  if ( !gtk_tree_selection_get_selected (sel, &model, &selected_row))
+    return;
 
-    gtk_tree_model_get(model,
-                       &selected_row,
-                       COL_SIDEBAR_INT,
-                       &int_data,
-                       -1);
+  gtk_tree_model_get (model,
+                      &selected_row,
+                      COL_SIDEBAR_INT,
+                      &int_data,
+                      -1);
 
-    gtk_notebook_set_current_page (GTK_NOTEBOOK (device_details_notebook), int_data);
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (device_details_notebook), int_data);
 }
 
 static void
 settings_quit (GtkWidget *widget, XfconfChannel *channel)
 {
-    g_object_unref (channel);
-    xfconf_shutdown();
-    gtk_widget_destroy (widget);
-    /* initiate the quit action on the application so it terminates */
-    g_action_group_activate_action(G_ACTION_GROUP(app), "quit", NULL);
+  g_object_unref (channel);
+  xfconf_shutdown ();
+  gtk_widget_destroy (widget);
+  /* initiate the quit action on the application so it terminates */
+  g_action_group_activate_action (G_ACTION_GROUP(app), "quit", NULL);
 }
 
 static void dialog_response_cb (GtkDialog *dialog, gint response, XfconfChannel *channel)
 {
-    switch(response)
-    {
-	case GTK_RESPONSE_HELP:
-	    xfce_dialog_show_help_with_version (NULL, "xfce4-power-manager", "start", NULL, XFPM_VERSION_SHORT);
-	    break;
-	default:
-	    settings_quit (GTK_WIDGET (dialog), channel);
-	    break;
-    }
+  switch(response)
+  {
+  case GTK_RESPONSE_HELP:
+    xfce_dialog_show_help_with_version (NULL, "xfce4-power-manager", "start", NULL, XFPM_VERSION_SHORT);
+    break;
+  default:
+    settings_quit (GTK_WIDGET (dialog), channel);
+    break;
+  }
 }
 
 static void
 delete_event_cb (GtkWidget *plug, GdkEvent *ev, XfconfChannel *channel)
 {
-    settings_quit (plug, channel);
+  settings_quit (plug, channel);
 }
 
 GtkWidget *
@@ -2317,251 +2300,251 @@ xfpm_settings_dialog_new (XfconfChannel *channel, gboolean auth_suspend,
                           gboolean has_battery_button,  Window id, gchar *device_id,
                           GtkApplication *gtk_app)
 {
-    GtkWidget *plug;
-    GtkWidget *parent;
-    GtkWidget *dialog;
-    GtkWidget *plugged_box;
-    GtkWidget *viewport;
-    GtkWidget *hbox;
-    GtkWidget *frame;
-    GtkWidget *switch_widget;
-    GtkWidget *stack;
-    GtkStyleContext *context;
-    GtkListStore *list_store;
-    GtkTreeViewColumn *col;
-    GtkCellRenderer *renderer;
-    GError *error = NULL;
-    guint val;
-    GtkCssProvider *css_provider;
-
-    XFPM_DEBUG ("auth_hibernate=%s auth_suspend=%s can_shutdown=%s can_suspend=%s can_hibernate=%s " \
-                "has_battery=%s has_lcd_brightness=%s has_lid=%s has_sleep_button=%s " \
-                "has_hibernate_button=%s has_power_button=%s has_battery_button=%s",
-      xfpm_bool_to_string (has_battery), xfpm_bool_to_string (auth_hibernate),
-	  xfpm_bool_to_string (can_shutdown), xfpm_bool_to_string (auth_suspend),
-	  xfpm_bool_to_string (can_suspend), xfpm_bool_to_string (can_hibernate),
-	  xfpm_bool_to_string (has_lcd_brightness), xfpm_bool_to_string (has_lid),
-	  xfpm_bool_to_string (has_sleep_button), xfpm_bool_to_string (has_hibernate_button),
-	  xfpm_bool_to_string (has_power_button), xfpm_bool_to_string (has_battery_button));
-
-    xml = xfpm_builder_new_from_string (xfpm_settings_ui, &error);
-
-    if ( G_UNLIKELY (error) )
-    {
-	xfce_dialog_show_error (NULL, error, "%s", _("Check your power manager installation"));
-	g_error ("%s", error->message);
-    }
-
-    lcd_brightness = has_lcd_brightness;
-    starting_device_id = device_id;
-
-    on_battery_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery"));
-    on_battery_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery"));
-    on_ac_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac"));
-    on_ac_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac"));
-
-    on_battery_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery"));
-    val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK, 1);
-    gtk_range_set_value (GTK_RANGE (on_battery_display_blank), val);
-    xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK,
-                            G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_battery_display_blank)),
-                            "value");
-
-    on_ac_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac"));
-    xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_AC_BLANK,
-                            G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_ac_display_blank)),
-                            "value");
-
-    switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
-    xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX HANDLE_BRIGHTNESS_KEYS,
-                            G_TYPE_BOOLEAN, switch_widget, "active");
-
-    switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-notifications"));
-    xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX GENERAL_NOTIFICATION_CFG,
-                            G_TYPE_BOOLEAN, switch_widget, "active");
-
-    switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-systray"));
-    xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX SHOW_TRAY_ICON_CFG,
-                            G_TYPE_BOOLEAN, switch_widget, "active");
-
-    dialog = GTK_WIDGET (gtk_builder_get_object (xml, "xfpm-settings-dialog"));
-    nt = GTK_WIDGET (gtk_builder_get_object (xml, "main-notebook"));
-
-    /* Set Gtk style */
-    css_provider = gtk_css_provider_new ();
-    gtk_css_provider_load_from_data (css_provider,
-                                     ".xfce4-scale-label { padding-bottom: 0; }",
-                                     -1, NULL);
-    gtk_style_context_add_provider_for_screen (gdk_screen_get_default(),
-                                               GTK_STYLE_PROVIDER(css_provider),
-                                               GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
-    g_object_unref (css_provider);
-
-    /* Devices listview */
-    sideview = gtk_tree_view_new ();
-    list_store = gtk_list_store_new (NCOLS_SIDEBAR,
-                                     GDK_TYPE_PIXBUF, /* COL_SIDEBAR_ICON */
-                                     G_TYPE_STRING,   /* COL_SIDEBAR_NAME */
-                                     G_TYPE_INT,      /* COL_SIDEBAR_INT */
-                                     G_TYPE_POINTER,  /* COL_SIDEBAR_BATTERY_DEVICE */
-                                     G_TYPE_STRING,   /* COL_SIDEBAR_OBJECT_PATH */
-                                     G_TYPE_ULONG,    /* COL_SIDEBAR_SIGNAL_ID */
-                                     G_TYPE_POINTER   /* COL_SIDEBAR_VIEW */
-                                     );
-
-    gtk_tree_view_set_model (GTK_TREE_VIEW (sideview), GTK_TREE_MODEL (list_store));
-
-    col = gtk_tree_view_column_new ();
-
-    renderer = gtk_cell_renderer_pixbuf_new ();
-
-    gtk_tree_view_column_pack_start (col, renderer, FALSE);
-    gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", 0, NULL);
-
-    /* The device label */
-    renderer = gtk_cell_renderer_text_new ();
-    gtk_tree_view_column_pack_start (col, renderer, FALSE);
-    gtk_tree_view_column_set_attributes (col, renderer, "markup", 1, NULL);
-
-    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sideview), FALSE);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (sideview), col);
-
-    g_signal_connect (sideview, "cursor-changed", G_CALLBACK (view_cursor_changed_cb), NULL);
-
-    /* Pack the content of the devices tab */
-    device_details_notebook = gtk_notebook_new ();
-
-    gtk_notebook_set_show_tabs (GTK_NOTEBOOK (device_details_notebook), FALSE);
-    context = gtk_widget_get_style_context (GTK_WIDGET (device_details_notebook));
-    gtk_style_context_add_class (context, "frame");
-    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
-
-    viewport = gtk_viewport_new (NULL, NULL);
-    gtk_container_add (GTK_CONTAINER (viewport), sideview);
-    gtk_box_pack_start (GTK_BOX (hbox), viewport, FALSE, FALSE, 0);
-    gtk_box_pack_start (GTK_BOX (hbox), device_details_notebook, TRUE, TRUE, 0);
-    gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
-    devices_page_num = gtk_notebook_append_page (GTK_NOTEBOOK (nt), hbox, gtk_label_new (_("Devices")) );
-
-    gtk_widget_show_all (sideview);
-    gtk_widget_show_all (viewport);
-    gtk_widget_show_all (hbox);
-    gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
-
-    settings_create_devices_list ();
-
-    xfpm_settings_on_ac (channel,
-                         auth_suspend,
-                         auth_hibernate,
-                         can_suspend,
-                         can_hibernate,
-                         has_lcd_brightness,
-                         has_lid);
-
-    if ( has_battery )
-    xfpm_settings_on_battery (channel,
-                              auth_suspend,
-                              auth_hibernate,
-                              can_suspend,
-                              can_hibernate,
-                              can_shutdown,
-                              has_lcd_brightness,
-                              has_lid);
-    else
-    {
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"critical-power-frame")));
-      stack = GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack"));
-      gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
-      stack = GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack"));
-      gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack-switcher")));
-      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack-switcher")));
-    }
-
-    xfpm_settings_general (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, can_shutdown,
-                           has_sleep_button, has_hibernate_button, has_power_button, has_battery_button);
-
-    xfpm_settings_advanced (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, has_battery);
-
-    /* Light Locker Integration */
-    xfpm_settings_light_locker (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate);
-    /* END Light Locker Integration */
-
-    if ( !has_lcd_brightness )
-    {
+  GtkWidget *plug;
+  GtkWidget *parent;
+  GtkWidget *dialog;
+  GtkWidget *plugged_box;
+  GtkWidget *viewport;
+  GtkWidget *hbox;
+  GtkWidget *frame;
+  GtkWidget *switch_widget;
+  GtkWidget *stack;
+  GtkStyleContext *context;
+  GtkListStore *list_store;
+  GtkTreeViewColumn *col;
+  GtkCellRenderer *renderer;
+  GError *error = NULL;
+  guint val;
+  GtkCssProvider *css_provider;
+
+  XFPM_DEBUG ("auth_hibernate=%s auth_suspend=%s can_shutdown=%s can_suspend=%s can_hibernate=%s " \
+              "has_battery=%s has_lcd_brightness=%s has_lid=%s has_sleep_button=%s " \
+              "has_hibernate_button=%s has_power_button=%s has_battery_button=%s",
+              xfpm_bool_to_string (has_battery), xfpm_bool_to_string (auth_hibernate),
+              xfpm_bool_to_string (can_shutdown), xfpm_bool_to_string (auth_suspend),
+              xfpm_bool_to_string (can_suspend), xfpm_bool_to_string (can_hibernate),
+              xfpm_bool_to_string (has_lcd_brightness), xfpm_bool_to_string (has_lid),
+              xfpm_bool_to_string (has_sleep_button), xfpm_bool_to_string (has_hibernate_button),
+              xfpm_bool_to_string (has_power_button), xfpm_bool_to_string (has_battery_button));
+
+  xml = xfpm_builder_new_from_string (xfpm_settings_ui, &error);
+
+  if ( G_UNLIKELY (error) )
+  {
+    xfce_dialog_show_error (NULL, error, "%s", _("Check your power manager installation"));
+    g_error ("%s", error->message);
+  }
+
+  lcd_brightness = has_lcd_brightness;
+  starting_device_id = device_id;
+
+  on_battery_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery"));
+  on_battery_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery"));
+  on_ac_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac"));
+  on_ac_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac"));
+
+  on_battery_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery"));
+  val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK, 1);
+  gtk_range_set_value (GTK_RANGE (on_battery_display_blank), val);
+  xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK,
+                          G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_battery_display_blank)),
+                          "value");
+
+  on_ac_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac"));
+  xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_AC_BLANK,
+                          G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_ac_display_blank)),
+                          "value");
+
+  switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
+  xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX HANDLE_BRIGHTNESS_KEYS,
+                          G_TYPE_BOOLEAN, switch_widget, "active");
+
+  switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-notifications"));
+  xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX GENERAL_NOTIFICATION_CFG,
+                          G_TYPE_BOOLEAN, switch_widget, "active");
+
+  switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-systray"));
+  xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX SHOW_TRAY_ICON_CFG,
+                          G_TYPE_BOOLEAN, switch_widget, "active");
+
+  dialog = GTK_WIDGET (gtk_builder_get_object (xml, "xfpm-settings-dialog"));
+  nt = GTK_WIDGET (gtk_builder_get_object (xml, "main-notebook"));
+
+  /* Set Gtk style */
+  css_provider = gtk_css_provider_new ();
+  gtk_css_provider_load_from_data (css_provider,
+                                   ".xfce4-scale-label { padding-bottom: 0; }",
+                                   -1, NULL);
+  gtk_style_context_add_provider_for_screen (gdk_screen_get_default(),
+                                             GTK_STYLE_PROVIDER(css_provider),
+                                             GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+  g_object_unref (css_provider);
+
+  /* Devices listview */
+  sideview = gtk_tree_view_new ();
+  list_store = gtk_list_store_new (NCOLS_SIDEBAR,
+                                   GDK_TYPE_PIXBUF, /* COL_SIDEBAR_ICON */
+                                   G_TYPE_STRING,   /* COL_SIDEBAR_NAME */
+                                   G_TYPE_INT,      /* COL_SIDEBAR_INT */
+                                   G_TYPE_POINTER,  /* COL_SIDEBAR_BATTERY_DEVICE */
+                                   G_TYPE_STRING,   /* COL_SIDEBAR_OBJECT_PATH */
+                                   G_TYPE_ULONG,    /* COL_SIDEBAR_SIGNAL_ID */
+                                   G_TYPE_POINTER   /* COL_SIDEBAR_VIEW */
+                                   );
+
+  gtk_tree_view_set_model (GTK_TREE_VIEW (sideview), GTK_TREE_MODEL (list_store));
+
+  col = gtk_tree_view_column_new ();
+
+  renderer = gtk_cell_renderer_pixbuf_new ();
+
+  gtk_tree_view_column_pack_start (col, renderer, FALSE);
+  gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", 0, NULL);
+
+  /* The device label */
+  renderer = gtk_cell_renderer_text_new ();
+  gtk_tree_view_column_pack_start (col, renderer, FALSE);
+  gtk_tree_view_column_set_attributes (col, renderer, "markup", 1, NULL);
+
+  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sideview), FALSE);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (sideview), col);
+
+  g_signal_connect (sideview, "cursor-changed", G_CALLBACK (view_cursor_changed_cb), NULL);
+
+  /* Pack the content of the devices tab */
+  device_details_notebook = gtk_notebook_new ();
+
+  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (device_details_notebook), FALSE);
+  context = gtk_widget_get_style_context (GTK_WIDGET (device_details_notebook));
+  gtk_style_context_add_class (context, "frame");
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
+
+  viewport = gtk_viewport_new (NULL, NULL);
+  gtk_container_add (GTK_CONTAINER (viewport), sideview);
+  gtk_box_pack_start (GTK_BOX (hbox), viewport, FALSE, FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (hbox), device_details_notebook, TRUE, TRUE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
+  devices_page_num = gtk_notebook_append_page (GTK_NOTEBOOK (nt), hbox, gtk_label_new (_("Devices")) );
+
+  gtk_widget_show_all (sideview);
+  gtk_widget_show_all (viewport);
+  gtk_widget_show_all (hbox);
+  gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
+
+  settings_create_devices_list ();
+
+  xfpm_settings_on_ac (channel,
+                       auth_suspend,
+                       auth_hibernate,
+                       can_suspend,
+                       can_hibernate,
+                       has_lcd_brightness,
+                       has_lid);
+
+  if ( has_battery )
+  xfpm_settings_on_battery (channel,
+                            auth_suspend,
+                            auth_hibernate,
+                            can_suspend,
+                            can_hibernate,
+                            can_shutdown,
+                            has_lcd_brightness,
+                            has_lid);
+  else
+  {
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"critical-power-frame")));
+    stack = GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack"));
+    gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
+    stack = GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack"));
+    gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack-switcher")));
+    gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack-switcher")));
+  }
+
+  xfpm_settings_general (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, can_shutdown,
+                         has_sleep_button, has_hibernate_button, has_power_button, has_battery_button);
+
+  xfpm_settings_advanced (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, has_battery);
+
+  /* Light Locker Integration */
+  xfpm_settings_light_locker (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate);
+  /* END Light Locker Integration */
+
+  if ( !has_lcd_brightness )
+  {
     frame = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-frame"));
     gtk_widget_hide (frame);
     frame = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
     gtk_widget_hide (frame);
     frame = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys-label"));
     gtk_widget_hide (frame);
-    }
+  }
 
-    if ( id != 0 )
-    {
-	plugged_box = GTK_WIDGET (gtk_builder_get_object (xml, "plug-child"));
-	plug = gtk_plug_new (id);
-	gtk_widget_show (plug);
+  if ( id != 0 )
+  {
+    plugged_box = GTK_WIDGET (gtk_builder_get_object (xml, "plug-child"));
+    plug = gtk_plug_new (id);
+    gtk_widget_show (plug);
 
     parent = gtk_widget_get_parent (plugged_box);
     if (parent)
     {
-        g_object_ref (plugged_box);
-        gtk_container_remove (GTK_CONTAINER (parent), plugged_box);
-        gtk_container_add (GTK_CONTAINER (plug), plugged_box);
-        g_object_unref (plugged_box);
+      g_object_ref (plugged_box);
+      gtk_container_remove (GTK_CONTAINER (parent), plugged_box);
+      gtk_container_add (GTK_CONTAINER (plug), plugged_box);
+      g_object_unref (plugged_box);
     }
 
-	g_signal_connect (plug, "delete-event",
-			  G_CALLBACK (delete_event_cb), channel);
-	gdk_notify_startup_complete ();
-    }
-    else
-    {
-	g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), channel);
-	gtk_widget_show (dialog);
-    }
+    g_signal_connect (plug, "delete-event",
+          G_CALLBACK (delete_event_cb), channel);
+    gdk_notify_startup_complete ();
+  }
+  else
+  {
+    g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), channel);
+    gtk_widget_show (dialog);
+  }
 
-    gtk_builder_connect_signals (xml, channel);
+  gtk_builder_connect_signals (xml, channel);
 
-    /* If we passed in a device to display, show the devices tab now, otherwise hide it */
-    if (device_id != NULL)
-    {
-	gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
-	gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
-    }
+  /* If we passed in a device to display, show the devices tab now, otherwise hide it */
+  if (device_id != NULL)
+  {
+    gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
+    gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
+  }
 
-    /* keep a pointer to the GtkApplication instance so we can signal a
-     * quit message */
-    app = gtk_app;
+  /* keep a pointer to the GtkApplication instance so we can signal a
+   * quit message */
+  app = gtk_app;
 
-    return dialog;
+  return dialog;
 }
 
 void
 xfpm_settings_show_device_id (gchar *device_id)
 {
-    GtkTreeIter *device_iter;
+  GtkTreeIter *device_iter;
 
-    if (device_id == NULL)
-	return;
+  if (device_id == NULL)
+    return;
 
-    gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
-    gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
+  gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
 
-    DBG("device_id %s", device_id);
+  DBG("device_id %s", device_id);
 
-    device_iter = find_device_in_tree (device_id);
-    if (device_iter)
-    {
-        GtkTreeSelection *selection;
+  device_iter = find_device_in_tree (device_id);
+  if (device_iter)
+  {
+    GtkTreeSelection *selection;
 
-	DBG("device found");
+    DBG("device found");
 
-	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
+    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
 
-	gtk_tree_selection_select_iter (selection, device_iter);
-	view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
-	gtk_tree_iter_free (device_iter);
-    }
+    gtk_tree_selection_select_iter (selection, device_iter);
+    view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
+    gtk_tree_iter_free (device_iter);
+  }
 }
diff --git a/settings/xfpm-settings.h b/settings/xfpm-settings.h
index 15888491..426b2085 100644
--- a/settings/xfpm-settings.h
+++ b/settings/xfpm-settings.h
@@ -24,23 +24,22 @@
 #include <gtk/gtkx.h>
 #include <xfconf/xfconf.h>
 
-GtkWidget *xfpm_settings_dialog_new (XfconfChannel *channel,
-                                     gboolean auth_suspend,
-                                     gboolean auth_hibernate,
-                                     gboolean can_suspend,
-                                     gboolean can_hibernate,
-                                     gboolean can_shutdown,
-                                     gboolean has_battery,
-                                     gboolean has_lcd_brightness,
-                                     gboolean has_lid,
-                                     gboolean has_sleep_button,
-                                     gboolean has_hibernate_button,
-                                     gboolean has_power_button,
-                                     gboolean has_battery_button,
-                                     Window id,
-                                     gchar *device_id,
-                                     GtkApplication *gtk_app);
-
+GtkWidget *xfpm_settings_dialog_new   (XfconfChannel *channel,
+                                       gboolean auth_suspend,
+                                       gboolean auth_hibernate,
+                                       gboolean can_suspend,
+                                       gboolean can_hibernate,
+                                       gboolean can_shutdown,
+                                       gboolean has_battery,
+                                       gboolean has_lcd_brightness,
+                                       gboolean has_lid,
+                                       gboolean has_sleep_button,
+                                       gboolean has_hibernate_button,
+                                       gboolean has_power_button,
+                                       gboolean has_battery_button,
+                                       Window id,
+                                       gchar *device_id,
+                                       GtkApplication *gtk_app);
 void     xfpm_settings_show_device_id (gchar *device_id);
 
 #endif /* __XFPM_SETTINGS_H */