[Xfce4-commits] [apps/xfce4-screensaver] 01/01: Add all settings to the preferences dialog

noreply at xfce.org noreply at xfce.org
Wed Nov 14 03:40:39 CET 2018


This is an automated email from the git hooks/post-receive script.

b   l   u   e   s   a   b   r   e       p   u   s   h   e   d       a       c   o   m   m   i   t       t   o       b   r   a   n   c   h       m   a   s   t   e   r   
   in repository apps/xfce4-screensaver.

commit e2b0ce807da60a1e64d8ab65044fd382a324332f
Author: Sean Davis <smd.seandavis at gmail.com>
Date:   Tue Nov 13 21:40:32 2018 -0500

    Add all settings to the preferences dialog
---
 src/xfce4-screensaver-preferences.c  | 775 +++++++++++++++++++++++++++--------
 src/xfce4-screensaver-preferences.ui | 713 +++++++++++++++++++++++++-------
 2 files changed, 1164 insertions(+), 324 deletions(-)

diff --git a/src/xfce4-screensaver-preferences.c b/src/xfce4-screensaver-preferences.c
index 94f795c..ffe1139 100644
--- a/src/xfce4-screensaver-preferences.c
+++ b/src/xfce4-screensaver-preferences.c
@@ -71,6 +71,12 @@ static GSThemeManager *theme_manager = NULL;
 static GSJob          *job = NULL;
 static XfconfChannel  *screensaver_channel = NULL;
 
+static gboolean        idle_delay_writable;
+static gboolean        lock_delay_writable;
+static gboolean        keyboard_command_writable;
+static gboolean        logout_command_writable;
+static gboolean        logout_delay_writable;
+
 static gint opt_socket_id = 0;
 static GOptionEntry entries[] = {
     { "socket-id", 's', G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_INT, &opt_socket_id,
@@ -79,7 +85,7 @@ static GOptionEntry entries[] = {
 };
 
 static gint32
-config_get_activate_delay (gboolean *is_writable) {
+config_get_idle_delay (gboolean *is_writable) {
     gint32 delay;
 
     if (is_writable) {
@@ -97,10 +103,79 @@ config_get_activate_delay (gboolean *is_writable) {
 }
 
 static void
-config_set_activate_delay (gint32 timeout) {
+config_set_idle_delay (gint32 timeout) {
     xfconf_channel_set_int (screensaver_channel, KEY_IDLE_DELAY, timeout);
 }
 
+static gint32
+config_get_lock_delay (gboolean *is_writable) {
+    gint32 delay;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                       KEY_LOCK_DELAY);
+    }
+
+    delay = xfconf_channel_get_int (screensaver_channel, KEY_LOCK_DELAY, DEFAULT_KEY_LOCK_DELAY);
+
+    if (delay < 1) {
+        delay = 1;
+    }
+
+    return delay;
+}
+
+static void
+config_set_lock_delay (gint32 timeout) {
+    xfconf_channel_set_int (screensaver_channel, KEY_LOCK_DELAY, timeout);
+}
+
+static gint32
+config_get_cycle_delay (gboolean *is_writable) {
+    gint32 delay;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                       KEY_CYCLE_DELAY);
+    }
+
+    delay = xfconf_channel_get_int (screensaver_channel, KEY_CYCLE_DELAY, DEFAULT_KEY_CYCLE_DELAY);
+
+    if (delay < 1) {
+        delay = 1;
+    }
+
+    return delay;
+}
+
+static void
+config_set_cycle_delay (gint32 timeout) {
+    xfconf_channel_set_int (screensaver_channel, KEY_CYCLE_DELAY, timeout);
+}
+
+static gint32
+config_get_logout_delay (gboolean *is_writable) {
+    gint32 delay;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                       KEY_LOGOUT_DELAY);
+    }
+
+    delay = xfconf_channel_get_int (screensaver_channel, KEY_LOGOUT_DELAY, DEFAULT_KEY_LOGOUT_DELAY);
+
+    if (delay < 1) {
+        delay = 1;
+    }
+
+    return delay;
+}
+
+static void
+config_set_logout_delay (gint32 timeout) {
+    xfconf_channel_set_int (screensaver_channel, KEY_LOGOUT_DELAY, timeout);
+}
+
 static int
 config_get_mode (gboolean *is_writable) {
     int mode;
@@ -118,6 +193,13 @@ config_get_mode (gboolean *is_writable) {
 static void
 config_set_mode (int mode) {
     xfconf_channel_set_int (screensaver_channel, KEY_MODE, mode);
+
+    gtk_widget_set_visible (GTK_WIDGET (gtk_builder_get_object (builder, "cycle_delay_label_left")),
+                            mode == GS_MODE_RANDOM);
+    gtk_widget_set_visible (GTK_WIDGET (gtk_builder_get_object (builder, "cycle_delay")),
+                            mode == GS_MODE_RANDOM);
+    gtk_widget_set_visible (GTK_WIDGET (gtk_builder_get_object (builder, "cycle_delay_label_right")),
+                            mode == GS_MODE_RANDOM);
 }
 
 static char *
@@ -208,12 +290,12 @@ config_set_theme (const char *theme_id) {
 }
 
 static gboolean
-config_get_enabled (gboolean *is_writable) {
+config_get_idle_activation_enabled (gboolean *is_writable) {
     int enabled;
 
     if (is_writable) {
         *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
-                                                           KEY_LOCK_ENABLED);
+                                                           KEY_IDLE_ACTIVATION_ENABLED);
     }
 
     enabled = xfconf_channel_get_bool (screensaver_channel,
@@ -224,14 +306,14 @@ config_get_enabled (gboolean *is_writable) {
 }
 
 static void
-config_set_enabled (gboolean enabled) {
+config_set_idle_activation_enabled (gboolean enabled) {
     xfconf_channel_set_bool (screensaver_channel,
                              KEY_IDLE_ACTIVATION_ENABLED,
                              enabled);
 }
 
 static gboolean
-config_get_lock (gboolean *is_writable) {
+config_get_lock_enabled (gboolean *is_writable) {
     gboolean lock;
 
     if (is_writable) {
@@ -247,10 +329,136 @@ config_get_lock (gboolean *is_writable) {
 }
 
 static void
-config_set_lock (gboolean lock) {
+config_set_lock_enabled (gboolean lock) {
     xfconf_channel_set_bool (screensaver_channel, KEY_LOCK_ENABLED, lock);
 }
 
+static gboolean
+config_get_keyboard_enabled (gboolean *is_writable) {
+    gboolean enabled;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                                                           KEY_KEYBOARD_ENABLED);
+    }
+
+    enabled = xfconf_channel_get_bool (screensaver_channel,
+                                       KEY_KEYBOARD_ENABLED,
+                                       DEFAULT_KEY_KEYBOARD_ENABLED);
+
+    return enabled;
+}
+
+static void
+config_set_keyboard_enabled (gboolean enabled) {
+    xfconf_channel_set_bool (screensaver_channel, KEY_KEYBOARD_ENABLED, enabled);
+}
+
+static gboolean
+config_get_status_message_enabled (gboolean *is_writable) {
+    gboolean enabled;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                                                           KEY_STATUS_MESSAGE_ENABLED);
+    }
+
+    enabled = xfconf_channel_get_bool (screensaver_channel,
+                                       KEY_STATUS_MESSAGE_ENABLED,
+                                       DEFAULT_KEY_STATUS_MESSAGE_ENABLED);
+
+    return enabled;
+}
+
+static void
+config_set_status_message_enabled (gboolean enabled) {
+    xfconf_channel_set_bool (screensaver_channel, KEY_STATUS_MESSAGE_ENABLED, enabled);
+}
+
+static gboolean
+config_get_logout_enabled (gboolean *is_writable) {
+    gboolean enabled;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                                                           KEY_LOGOUT_ENABLED);
+    }
+
+    enabled = xfconf_channel_get_bool (screensaver_channel,
+                                       KEY_LOGOUT_ENABLED,
+                                       DEFAULT_KEY_LOGOUT_ENABLED);
+
+    return enabled;
+}
+
+static void
+config_set_logout_enabled (gboolean enabled) {
+    xfconf_channel_set_bool (screensaver_channel, KEY_LOGOUT_ENABLED, enabled);
+}
+
+static gboolean
+config_get_user_switch_enabled (gboolean *is_writable) {
+    gboolean enabled;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked (screensaver_channel,
+                                                           KEY_USER_SWITCH_ENABLED);
+    }
+
+    enabled = xfconf_channel_get_bool (screensaver_channel,
+                                       KEY_USER_SWITCH_ENABLED,
+                                       DEFAULT_KEY_USER_SWITCH_ENABLED);
+
+    return enabled;
+}
+
+static void
+config_set_user_switch_enabled (gboolean enabled) {
+    xfconf_channel_set_bool (screensaver_channel, KEY_USER_SWITCH_ENABLED, enabled);
+}
+
+static gchar*
+config_get_keyboard_command (gboolean *is_writable) {
+    gchar *command;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked(screensaver_channel,
+                                                          KEY_KEYBOARD_COMMAND);
+    }
+
+    command = xfconf_channel_get_string (screensaver_channel,
+                                         KEY_KEYBOARD_COMMAND,
+                                         DEFAULT_KEY_KEYBOARD_COMMAND);
+
+    return command;
+}
+
+static void
+config_set_keyboard_command (const gchar *command) {
+    xfconf_channel_set_string (screensaver_channel, KEY_KEYBOARD_COMMAND, command);
+}
+
+static gchar*
+config_get_logout_command (gboolean *is_writable) {
+    gchar *command;
+
+    if (is_writable) {
+        *is_writable = !xfconf_channel_is_property_locked(screensaver_channel,
+                                                          KEY_LOGOUT_COMMAND);
+    }
+
+    command = xfconf_channel_get_string (screensaver_channel,
+                                         KEY_LOGOUT_COMMAND,
+                                         DEFAULT_KEY_LOGOUT_COMMAND);
+
+    return command;
+}
+
+static void
+config_set_logout_command (const gchar *command) {
+    xfconf_channel_set_string (screensaver_channel, KEY_LOGOUT_COMMAND, command);
+}
+
 static void
 job_set_theme (GSJob      *job,
                const char *theme) {
@@ -487,12 +695,59 @@ tree_selection_changed_cb (GtkTreeSelection *selection,
 }
 
 static void
-activate_delay_value_changed_cb (GtkRange *range,
+idle_delay_value_changed_cb (GtkSpinButton *spin,
+                                 gpointer  user_data) {
+    gdouble value;
+
+    value = gtk_spin_button_get_value (spin);
+    config_set_idle_delay ((gint32)value);
+}
+
+static void
+lock_delay_value_changed_cb (GtkSpinButton *spin,
+                                 gpointer  user_data) {
+    gdouble value;
+
+    value = gtk_spin_button_get_value (spin);
+    config_set_lock_delay ((gint32)value);
+}
+
+static void
+cycle_delay_value_changed_cb (GtkSpinButton *spin,
+                                 gpointer  user_data) {
+    gdouble value;
+
+    value = gtk_spin_button_get_value (spin);
+    config_set_cycle_delay ((gint32)value);
+}
+
+static void
+logout_delay_value_changed_cb (GtkSpinButton *spin,
                                  gpointer  user_data) {
     gdouble value;
 
-    value = gtk_range_get_value (range);
-    config_set_activate_delay ((gint32)value);
+    value = gtk_spin_button_get_value (spin);
+    config_set_logout_delay ((gint32)value);
+}
+
+static void
+keyboard_command_changed_cb (GtkEntry *widget,
+                             gpointer  user_data)
+{
+    const gchar *value;
+
+    value = gtk_entry_get_text (widget);
+    config_set_keyboard_command (value);
+}
+
+static void
+logout_command_changed_cb (GtkEntry *widget,
+                           gpointer  user_data)
+{
+    const gchar *value;
+
+    value = gtk_entry_get_text (widget);
+    config_set_logout_command (value);
 }
 
 static int
@@ -806,196 +1061,283 @@ drag_data_received_cb (GtkWidget        *widget,
     }
 }
 
-/* Adapted from totem_time_to_string_text */
-static char *
-time_to_string_text (long time) {
-    char *secs, *mins, *hours, *string;
-    int   sec, min, hour;
-    int   n, inc_len, len_minutes;
-
-    sec = time % 60;
-    time = time - sec;
-    min = (time % (60 * 60)) / 60;
-    time = time - (min * 60);
-    hour = time / (60 * 60);
+static void
+lock_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    gboolean writable;
 
-    hours = g_strdup_printf (ngettext ("%d hour",
-                                       "%d hours", hour), hour);
+    config_set_lock_enabled (gtk_switch_get_active (widget));
 
-    mins = g_strdup_printf (ngettext ("%d minute",
-                                      "%d minutes", min), min);
+    writable = lock_delay_writable && gtk_switch_get_active (widget);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay_label_right")), writable);
+}
 
-    secs = g_strdup_printf (ngettext ("%d second",
-                                      "%d seconds", sec), sec);
+static void
+idle_activation_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    gboolean writable;
 
-    inc_len = strlen (g_strdup_printf (_("%s %s"),
-                      g_strdup_printf (ngettext ("%d hour",
-                                                 "%d hours", 1), 1),
-                      g_strdup_printf (ngettext ("%d minute",
-                                                 "%d minutes", 59), 59))) - 1;
+    config_set_idle_activation_enabled (gtk_switch_get_active (widget));
 
-    len_minutes = 0;
+    writable = idle_delay_writable && gtk_switch_get_active (widget);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay_label_right")), writable);
+}
 
-    for (n = 2; n < 60; n++) {
-        if (n < 10) {
-            if ((strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                                    "%d minutes", n), n), NULL)) - 2) > len_minutes)
+static void
+logout_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    gboolean writable;
 
-                len_minutes = strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                                                 "%d minutes", n), n), NULL)) - 2;
-        } else {
-            if ((strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                                    "%d minutes", n), n), NULL)) - 3) > len_minutes)
+    config_set_logout_enabled (gtk_switch_get_active (widget));
 
-                len_minutes = strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                                                 "%d minutes", n), n), NULL)) - 3;
-        }
-    }
+    writable = logout_command_writable && gtk_switch_get_active (widget);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_command_label")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_command")), writable);
 
-    if ((strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                            "%d minutes", 1), 1), NULL)) - 2) > len_minutes)
+    writable = logout_delay_writable && gtk_switch_get_active (widget);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay_label_right")), writable);
+}
 
-        len_minutes = strlen (g_str_to_ascii (g_strdup_printf (ngettext ("%d minute",
-                                                                         "%d minutes", 1), 1), NULL)) - 2;
+static void
+status_message_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    config_set_status_message_enabled (gtk_switch_get_active (widget));
+}
 
-    if (len_minutes < 1)
-        len_minutes = 1;
+static void
+user_switch_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    config_set_user_switch_enabled (gtk_switch_get_active (widget));
+}
 
-    if (hour > 0) {
-        if (sec > 0) {
-            /* hour:minutes:seconds */
-            string = g_strdup_printf (_("%s %s %s"), hours, mins, secs);
-        } else if (min > 0) {
-            /* hour:minutes */
-            string = g_strdup_printf (_("%s %s"), hours, mins);
-        } else {
-            /* hour */
-            string = g_strdup_printf (_("%s"), hours);
-        }
-    } else if (min > 0) {
-        if (sec > 0) {
-            /* minutes:seconds */
-            string = g_strdup_printf (_("%s %s"), mins, secs);
-        } else {
-            /* minutes */
-            string = g_strdup_printf (_("%s"), mins);
-
-            if (min < 10) {
-                if (min == 1) {
-                    while (strlen (string) != (len_minutes + inc_len + 3)) {
-                        if (strlen (string) % 2 == 0)
-                            string = g_strconcat (string, " ", NULL);
-                        else
-                            string = g_strconcat (" " , string, NULL);
-                    }
-                } else {
-                    while (strlen (string) != (len_minutes + inc_len)) {
-                        if (strlen (string) % 2 == 0)
-                            string = g_strconcat (string, " ", NULL);
-                        else
-                            string = g_strconcat (" " , string, NULL);
-                    }
-                }
-            } else {
-                while (strlen (string) != (len_minutes + inc_len - 1)) {
-                    if (strlen (string) % 2 == 0)
-                        string = g_strconcat (string, " ", NULL);
-                    else
-                        string = g_strconcat (" " , string, NULL);
-                }
-            }
-        }
-    } else {
-        /* seconds */
-        string = g_strdup_printf (_("%s"), secs);
-    }
+static void
+keyboard_toggled_cb (GtkSwitch *widget, gpointer user_data) {
+    gboolean writable;
 
-    g_free (hours);
-    g_free (mins);
-    g_free (secs);
+    config_set_keyboard_enabled (gtk_switch_get_active (widget));
 
-    return string;
+    writable = keyboard_command_writable && gtk_switch_get_active (widget);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command_label")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command")), writable);
 }
 
-static char *
-format_value_callback_time (GtkScale *scale,
-                            gdouble   value) {
-    if (value == 0)
-        return g_strdup_printf (_("Never"));
+static void
+ui_set_lock_enabled (gboolean enabled) {
+    GtkWidget *widget;
+    gboolean   active;
+    gboolean   writable;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_enabled"));
+
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
+    if (active != enabled) {
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
+    }
 
-    return time_to_string_text (value * 60.0);
+    writable = lock_delay_writable && enabled;
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay_label_right")), writable);
 }
 
 static void
-lock_checkbox_toggled (GtkToggleButton *button, gpointer user_data) {
-    config_set_lock (gtk_toggle_button_get_active (button));
+ui_set_idle_activation_enabled (gboolean enabled) {
+    GtkWidget *widget;
+    gboolean   active;
+    gboolean   writable;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "idle_activation_enabled"));
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
+    if (active != enabled) {
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
+    }
+
+    writable = idle_delay_writable && enabled;
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay_label_right")), writable);
 }
 
 static void
-enabled_checkbox_toggled (GtkToggleButton *button, gpointer user_data) {
-    config_set_enabled (gtk_toggle_button_get_active (button));
+ui_set_keyboard_enabled (gboolean enabled) {
+    GtkWidget *widget;
+    gboolean   active;
+    gboolean   writable;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_enabled"));
+
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
+    if (active != enabled) {
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
+    }
+
+    writable = keyboard_command_writable && enabled;
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command_label")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command")), writable);
 }
 
 static void
-ui_set_lock (gboolean enabled) {
+ui_set_logout_enabled (gboolean enabled) {
     GtkWidget *widget;
     gboolean   active;
+    gboolean   writable;
 
-    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox"));
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_enabled"));
 
-    active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
     if (active != enabled) {
-        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), enabled);
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
     }
+
+    writable = logout_command_writable && enabled;
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_command_label")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_command")), writable);
+
+    writable = logout_delay_writable && enabled;
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay_label_left")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay")), writable);
+    gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay_label_right")), writable);
 }
 
 static void
-ui_set_enabled (gboolean enabled) {
+ui_set_idle_delay (int delay) {
+    GtkWidget *widget;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay"));
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), delay);
+}
+
+static void
+ui_set_lock_delay (int delay) {
+    GtkWidget *widget;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay"));
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), delay);
+}
+
+static void
+ui_set_cycle_delay (int delay) {
+    GtkWidget *widget;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_delay"));
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), delay);
+}
+
+static void
+ui_set_keyboard_command (gchar *command) {
+    GtkWidget   *widget;
+    const gchar *current;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command"));
+
+    current = gtk_entry_get_text (GTK_ENTRY (widget));
+    if (g_strcmp0 (current, command) != 0) {
+        gtk_entry_set_text (GTK_ENTRY (widget), command);
+    }
+}
+
+static void
+ui_set_status_message_enabled (gboolean enabled) {
     GtkWidget *widget;
     gboolean   active;
-    gboolean   is_writable;
 
-    widget = GTK_WIDGET (gtk_builder_get_object (builder, "enable_checkbox"));
-    active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "status_message_enabled"));
+
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
     if (active != enabled) {
-        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), enabled);
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
     }
+}
 
-    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox"));
-    config_get_lock (&is_writable);
-    if (is_writable) {
-        gtk_widget_set_sensitive (widget, enabled);
+static void
+ui_set_logout_delay (int delay) {
+    GtkWidget *widget;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay"));
+    gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), delay);
+}
+
+static void
+ui_set_logout_command (gchar *command) {
+    GtkWidget   *widget;
+    const gchar *current;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_command"));
+
+    current = gtk_entry_get_text (GTK_ENTRY (widget));
+    if (g_strcmp0 (current, command) != 0) {
+        gtk_entry_set_text (GTK_ENTRY (widget), command);
     }
 }
 
 static void
-ui_set_delay (int delay) {
+ui_set_user_switch_enabled (gboolean enabled) {
     GtkWidget *widget;
+    gboolean   active;
+
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "user_switch_enabled"));
 
-    widget = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hscale"));
-    gtk_range_set_value (GTK_RANGE (widget), delay);
+    active = gtk_switch_get_active (GTK_SWITCH (widget));
+    if (active != enabled) {
+        gtk_switch_set_active (GTK_SWITCH (widget), enabled);
+    }
 }
 
 static void
 key_changed_cb (XfconfChannel *channel, const gchar *key, gpointer data) {
-    if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0) {
+    if (strcmp (key, KEY_IDLE_DELAY) == 0) {
+        int delay;
+        delay = xfconf_channel_get_int (channel, key, DEFAULT_KEY_IDLE_DELAY);
+        ui_set_idle_delay (delay);
+    } else if (strcmp (key, KEY_LOCK_DELAY) == 0) {
+        int delay;
+        delay = xfconf_channel_get_int (channel, key, DEFAULT_KEY_LOCK_DELAY);
+        ui_set_lock_delay (delay);
+    } else if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0) {
         gboolean enabled;
         enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_IDLE_ACTIVATION_ENABLED);
-        ui_set_enabled (enabled);
+        ui_set_idle_activation_enabled (enabled);
     } else if (strcmp (key, KEY_LOCK_ENABLED) == 0) {
         gboolean enabled;
         enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_LOCK_ENABLED);
-        ui_set_lock (enabled);
+        ui_set_lock_enabled (enabled);
+    } else if (strcmp (key, KEY_CYCLE_DELAY) == 0) {
+        int delay;
+        delay = xfconf_channel_get_int (channel, key, DEFAULT_KEY_CYCLE_DELAY);
+        ui_set_cycle_delay (delay);
+    } else if (strcmp (key, KEY_KEYBOARD_ENABLED) == 0) {
+        gboolean enabled;
+        enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_KEYBOARD_ENABLED);
+        ui_set_keyboard_enabled (enabled);
+    } else if (strcmp (key, KEY_KEYBOARD_COMMAND) == 0) {
+        gchar *cmd;
+        cmd = xfconf_channel_get_string (channel, key, DEFAULT_KEY_KEYBOARD_COMMAND);
+        ui_set_keyboard_command (cmd);
+    } else if (strcmp (key, KEY_STATUS_MESSAGE_ENABLED) == 0) {
+        gboolean enabled;
+        enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_STATUS_MESSAGE_ENABLED);
+        ui_set_status_message_enabled (enabled);
+    } else if (strcmp (key, KEY_LOGOUT_ENABLED) == 0) {
+        gboolean enabled;
+        enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_LOGOUT_ENABLED);
+        ui_set_logout_enabled (enabled);
+    } else if (strcmp (key, KEY_LOGOUT_DELAY) == 0) {
+        int delay;
+        delay = xfconf_channel_get_int (channel, key, DEFAULT_KEY_LOGOUT_DELAY);
+        ui_set_logout_delay (delay);
+    } else if (strcmp (key, KEY_LOGOUT_COMMAND) == 0) {
+        gchar *cmd;
+        cmd = xfconf_channel_get_string (channel, key, DEFAULT_KEY_LOGOUT_COMMAND);
+        ui_set_logout_command (cmd);
+    } else if (strcmp (key, KEY_USER_SWITCH_ENABLED) == 0) {
+        gboolean enabled;
+        enabled = xfconf_channel_get_bool (channel, key, DEFAULT_KEY_USER_SWITCH_ENABLED);
+        ui_set_user_switch_enabled (enabled);
     } else if (strcmp (key, KEY_THEMES) == 0) {
         GtkWidget *treeview;
         treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview"));
         setup_treeview_selection (treeview);
-    } else if (strcmp (key, KEY_IDLE_DELAY) == 0) {
-        int delay;
-        delay = xfconf_channel_get_int (channel, key, DEFAULT_KEY_IDLE_DELAY);
-        ui_set_delay (delay);
-    } else {
-        /*g_warning ("Config key not handled: %s", key);*/
     }
 }
 
@@ -1117,10 +1459,9 @@ setup_for_root_user (void) {
     GtkWidget *lock_checkbox;
     GtkWidget *infobar;
 
-    lock_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox"));
+    lock_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "lock_enabled"));
     infobar = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_infobar"));
-
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (lock_checkbox), FALSE);
+    gtk_switch_set_active (GTK_SWITCH (lock_checkbox), FALSE);
     gtk_widget_set_sensitive (lock_checkbox, FALSE);
 
     gtk_widget_show (infobar);
@@ -1328,17 +1669,22 @@ is_program_in_path (const char *program) {
 }
 
 static void
+set_widget_writable (GtkWidget *widget, 
+                     gboolean writable)
+{
+    gtk_widget_set_sensitive (widget, writable);
+    if (!writable) {
+        gtk_widget_set_tooltip_text (widget, _("Setting locked by administrator."));
+    }
+}
+
+static void
 configure_capplet (void) {
     GtkWidget *dialog;
     GtkWidget *plug_child;
     GtkWidget *preview;
     GtkWidget *treeview;
     GtkWidget *list_scroller;
-    GtkWidget *activate_delay_hscale;
-    GtkWidget *activate_delay_hbox;
-    GtkWidget *label;
-    GtkWidget *enabled_checkbox;
-    GtkWidget *lock_checkbox;
     GtkWidget *root_warning_infobar;
     GtkWidget *preview_button;
     GtkWidget *gpm_button;
@@ -1347,9 +1693,13 @@ configure_capplet (void) {
     GtkWidget *fullscreen_preview_previous;
     GtkWidget *fullscreen_preview_next;
     GtkWidget *fullscreen_preview_close;
-    gdouble    activate_delay;
+
+    GtkWidget *widget;
+    gdouble    delay;
     gboolean   enabled;
     gboolean   is_writable;
+    gchar     *command;
+
     GError    *error = NULL;
     gint       mode;
 
@@ -1380,10 +1730,6 @@ configure_capplet (void) {
     plug_child                  = GTK_WIDGET (gtk_builder_get_object (builder, "plug-child"));
     treeview                    = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview"));
     list_scroller               = GTK_WIDGET (gtk_builder_get_object (builder, "themes_scrolled_window"));
-    activate_delay_hscale       = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hscale"));
-    activate_delay_hbox         = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hbox"));
-    enabled_checkbox            = GTK_WIDGET (gtk_builder_get_object (builder, "enable_checkbox"));
-    lock_checkbox               = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox"));
     root_warning_infobar        = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_infobar"));
     preview_button              = GTK_WIDGET (gtk_builder_get_object (builder, "preview_button"));
     gpm_button                  = GTK_WIDGET (gtk_builder_get_object (builder, "gpm_button"));
@@ -1393,11 +1739,6 @@ configure_capplet (void) {
     fullscreen_preview_previous = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_previous_button"));
     fullscreen_preview_next     = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_next_button"));
 
-    label = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_label"));
-    gtk_label_set_mnemonic_widget (GTK_LABEL (label), activate_delay_hscale);
-    label = GTK_WIDGET (gtk_builder_get_object (builder, "savers_label"));
-    gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
-
     gtk_widget_set_no_show_all (root_warning_infobar, TRUE);
     widget_set_best_visual (preview);
 
@@ -1412,28 +1753,103 @@ configure_capplet (void) {
                       G_CALLBACK (key_changed_cb),
                       NULL);
 
-    activate_delay = config_get_activate_delay (&is_writable);
-    ui_set_delay (activate_delay);
-    if (!is_writable) {
-        gtk_widget_set_sensitive (activate_delay_hbox, FALSE);
-    }
-    g_signal_connect (activate_delay_hscale, "format-value",
-                      G_CALLBACK (format_value_callback_time), NULL);
+    /* Idle delay */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "idle_delay"));
+    delay = config_get_idle_delay (&idle_delay_writable);
+    ui_set_idle_delay (delay);
+    set_widget_writable (widget, idle_delay_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (idle_delay_value_changed_cb), NULL);
+
+    /* Lock delay */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_delay"));
+    delay = config_get_lock_delay (&lock_delay_writable);
+    ui_set_lock_delay (delay);
+    set_widget_writable (widget, lock_delay_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (lock_delay_value_changed_cb), NULL);
+
+    /* Keyboard command */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_command"));
+    command = config_get_keyboard_command (&keyboard_command_writable);
+    ui_set_keyboard_command (command);
+    set_widget_writable (widget, keyboard_command_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (keyboard_command_changed_cb), NULL);
+    g_free (command);
 
-    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (lock_checkbox), config_get_lock (&is_writable));
-    if (!is_writable) {
-        gtk_widget_set_sensitive (lock_checkbox, FALSE);
-    }
-    g_signal_connect (lock_checkbox, "toggled",
-                      G_CALLBACK (lock_checkbox_toggled), NULL);
+    /* Logout command */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_command"));
+    command = config_get_logout_command (&logout_command_writable);
+    ui_set_logout_command (command);
+    set_widget_writable (widget, logout_command_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (logout_command_changed_cb), NULL);
+    g_free (command);
 
-    enabled = config_get_enabled (&is_writable);
-    ui_set_enabled (enabled);
-    if (!is_writable) {
-        gtk_widget_set_sensitive (enabled_checkbox, FALSE);
-    }
-    g_signal_connect (enabled_checkbox, "toggled",
-                      G_CALLBACK (enabled_checkbox_toggled), NULL);
+    /* Logout delay */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_delay"));
+    delay = config_get_logout_delay (&logout_delay_writable);
+    ui_set_logout_delay (delay);
+    set_widget_writable (widget, logout_delay_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (logout_delay_value_changed_cb), NULL);
+
+    /* Idle activation enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "idle_activation_enabled"));
+    enabled = config_get_idle_activation_enabled (&is_writable);
+    ui_set_idle_activation_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (idle_activation_toggled_cb), NULL);
+
+    /* Lock enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_enabled"));
+    enabled = config_get_lock_enabled (&is_writable);
+    ui_set_lock_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (lock_toggled_cb), NULL);
+
+    /* Cycle delay */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_delay"));
+    delay = config_get_cycle_delay (&is_writable);
+    ui_set_cycle_delay (delay);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "changed",
+                      G_CALLBACK (cycle_delay_value_changed_cb), NULL);
+
+    /* Keyboard enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_enabled"));
+    enabled = config_get_keyboard_enabled (&is_writable);
+    ui_set_keyboard_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (keyboard_toggled_cb), NULL);
+
+    /* Status message enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "status_message_enabled"));
+    enabled = config_get_status_message_enabled (&is_writable);
+    ui_set_status_message_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (status_message_toggled_cb), NULL);
+
+    /* Status message enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "logout_enabled"));
+    enabled = config_get_logout_enabled (&is_writable);
+    ui_set_logout_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (logout_toggled_cb), NULL);
+
+    /* User switch enabled */
+    widget = GTK_WIDGET (gtk_builder_get_object (builder, "user_switch_enabled"));
+    enabled = config_get_user_switch_enabled (&is_writable);
+    ui_set_user_switch_enabled (enabled);
+    set_widget_writable (widget, is_writable);
+    g_signal_connect (widget, "notify::active",
+                      G_CALLBACK (user_switch_toggled_cb), NULL);
 
     setup_list_size_constraint (list_scroller, treeview);
     gtk_widget_set_size_request (preview, 480, 300);
@@ -1473,9 +1889,6 @@ configure_capplet (void) {
         setup_for_root_user ();
     }
 
-    g_signal_connect (activate_delay_hscale, "value-changed",
-                      G_CALLBACK (activate_delay_value_changed_cb), NULL);
-
     g_signal_connect (preview_button, "clicked",
                       G_CALLBACK (fullscreen_preview_start_cb),
                       treeview);
diff --git a/src/xfce4-screensaver-preferences.ui b/src/xfce4-screensaver-preferences.ui
index c758a0f..d68d548 100644
--- a/src/xfce4-screensaver-preferences.ui
+++ b/src/xfce4-screensaver-preferences.ui
@@ -39,6 +39,32 @@ Simon Steinbeiß
     <property name="step_increment">1</property>
     <property name="page_increment">10</property>
   </object>
+  <object class="GtkAdjustment" id="adjustment2">
+    <property name="lower">1</property>
+    <property name="upper">1440</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment3">
+    <property name="upper">100</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment4">
+    <property name="upper">100</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment5">
+    <property name="upper">100</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment6">
+    <property name="upper">100</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+  </object>
   <object class="GtkWindow" id="fullscreen_preview_window">
     <property name="can_focus">True</property>
     <property name="has_focus">True</property>
@@ -255,21 +281,22 @@ Simon Steinbeiß
                 <property name="expand">False</property>
                 <property name="fill">False</property>
                 <property name="position">1</property>
+                <property name="secondary">True</property>
               </packing>
             </child>
             <child>
               <object class="GtkButton" id="preview_button">
-                <property name="label" translatable="yes">_Preview</property>
+                <property name="label" translatable="yes">Preview</property>
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">False</property>
+                <property name="receives_default">True</property>
+                <property name="halign">end</property>
+                <property name="valign">center</property>
                 <property name="image">preview_image</property>
-                <property name="use_underline">True</property>
               </object>
               <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
                 <property name="position">2</property>
               </packing>
             </child>
@@ -500,41 +527,75 @@ Simon Steinbeiß
               </packing>
             </child>
             <child>
-              <object class="GtkBox" id="hbox1">
+              <object class="GtkNotebook" id="notebook">
                 <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="spacing">12</property>
+                <property name="can_focus">True</property>
                 <child>
-                  <object class="GtkBox" id="vbox8">
+                  <object class="GtkBox">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
+                    <property name="border_width">12</property>
                     <property name="orientation">vertical</property>
-                    <property name="spacing">6</property>
+                    <property name="spacing">12</property>
                     <child>
-                      <object class="GtkLabel" id="savers_label">
+                      <object class="GtkBox">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
-                        <property name="halign">start</property>
-                        <property name="label" translatable="yes">_Screensaver theme:</property>
-                        <property name="use_markup">True</property>
-                        <property name="use_underline">True</property>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="label" translatable="yes">Enable Screensaver</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="enable_screensaver">
+                            <property name="visible">True</property>
+                            <property name="sensitive">False</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="active">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="pack_type">end</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
                       </object>
                       <packing>
                         <property name="expand">False</property>
-                        <property name="fill">False</property>
+                        <property name="fill">True</property>
                         <property name="position">0</property>
                       </packing>
                     </child>
                     <child>
-                      <object class="GtkBox" id="hbox6">
+                      <object class="GtkGrid" id="screensaver_grid">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
+                        <property name="vexpand">True</property>
+                        <property name="row_spacing">6</property>
+                        <property name="column_spacing">6</property>
                         <child>
                           <object class="GtkGrid" id="grid1">
                             <property name="visible">True</property>
                             <property name="can_focus">False</property>
+                            <property name="margin_top">14</property>
+                            <property name="margin_bottom">6</property>
+                            <property name="vexpand">True</property>
                             <property name="row_spacing">6</property>
-                            <property name="column_spacing">6</property>
+                            <property name="column_spacing">12</property>
                             <child>
                               <object class="GtkScrolledWindow" id="themes_scrolled_window">
                                 <property name="visible">True</property>
@@ -558,7 +619,7 @@ Simon Steinbeiß
                               </object>
                               <packing>
                                 <property name="left_attach">0</property>
-                                <property name="top_attach">0</property>
+                                <property name="top_attach">1</property>
                               </packing>
                             </child>
                             <child>
@@ -570,175 +631,541 @@ Simon Steinbeiß
                               </object>
                               <packing>
                                 <property name="left_attach">1</property>
+                                <property name="top_attach">1</property>
+                                <property name="width">2</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can_focus">False</property>
+                                <property name="label" translatable="yes">Theme</property>
+                                <property name="xalign">0</property>
+                                <property name="yalign">1</property>
+                                <attributes>
+                                  <attribute name="weight" value="bold"/>
+                                </attributes>
+                              </object>
+                              <packing>
+                                <property name="left_attach">0</property>
+                                <property name="top_attach">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkLabel">
+                                <property name="visible">True</property>
+                                <property name="can_focus">False</property>
+                                <property name="label" translatable="yes">Preview</property>
+                                <property name="xalign">0</property>
+                                <property name="yalign">1</property>
+                                <attributes>
+                                  <attribute name="weight" value="bold"/>
+                                </attributes>
+                              </object>
+                              <packing>
+                                <property name="left_attach">1</property>
                                 <property name="top_attach">0</property>
+                                <property name="width">2</property>
                               </packing>
                             </child>
                           </object>
                           <packing>
-                            <property name="expand">True</property>
-                            <property name="fill">True</property>
-                            <property name="position">0</property>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">0</property>
+                            <property name="width">3</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="cycle_delay_label_left">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="hexpand">True</property>
+                            <property name="label" translatable="yes">Change theme after:</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="label" translatable="yes">Activate screensaver when computer is idle</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="idle_activation_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">2</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="idle_delay_label_left">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_left">12</property>
+                            <property name="hexpand">True</property>
+                            <property name="label" translatable="yes">Regard the computer as _idle after:</property>
+                            <property name="use_underline">True</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">3</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSpinButton" id="cycle_delay">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="adjustment">adjustment5</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSpinButton" id="idle_delay">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="adjustment">adjustment6</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">3</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="cycle_delay_label_right">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="label" translatable="yes">minutes</property>
+                            <attributes>
+                              <attribute name="style" value="italic"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="idle_delay_label_right">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="label" translatable="yes">minutes</property>
+                            <attributes>
+                              <attribute name="style" value="italic"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">3</property>
                           </packing>
                         </child>
                       </object>
                       <packing>
-                        <property name="expand">True</property>
+                        <property name="expand">False</property>
                         <property name="fill">True</property>
                         <property name="position">1</property>
                       </packing>
                     </child>
                   </object>
+                </child>
+                <child type="tab">
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="label" translatable="yes">Screensaver</property>
+                  </object>
                   <packing>
-                    <property name="expand">True</property>
-                    <property name="fill">True</property>
-                    <property name="position">0</property>
+                    <property name="tab_fill">False</property>
                   </packing>
                 </child>
-              </object>
-              <packing>
-                <property name="expand">True</property>
-                <property name="fill">True</property>
-                <property name="position">2</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkBox" id="hbox2">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
                 <child>
-                  <object class="GtkBox" id="vbox5">
+                  <object class="GtkBox">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
+                    <property name="border_width">12</property>
                     <property name="orientation">vertical</property>
+                    <property name="spacing">12</property>
                     <child>
-                      <object class="GtkBox" id="hbox3">
+                      <object class="GtkBox">
                         <property name="visible">True</property>
                         <property name="can_focus">False</property>
                         <child>
-                          <object class="GtkBox" id="vbox6">
+                          <object class="GtkLabel">
                             <property name="visible">True</property>
                             <property name="can_focus">False</property>
-                            <property name="orientation">vertical</property>
-                            <child>
-                              <object class="GtkBox" id="vbox3">
-                                <property name="visible">True</property>
-                                <property name="can_focus">False</property>
-                                <property name="orientation">vertical</property>
-                                <property name="spacing">6</property>
-                                <child>
-                                  <object class="GtkBox" id="activate_delay_hbox">
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">False</property>
-                                    <property name="spacing">12</property>
-                                    <child>
-                                      <object class="GtkLabel" id="activate_delay_label">
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">False</property>
-                                        <property name="label" translatable="yes">Regard the computer as _idle after:</property>
-                                        <property name="use_underline">True</property>
-                                      </object>
-                                      <packing>
-                                        <property name="expand">False</property>
-                                        <property name="fill">False</property>
-                                        <property name="position">0</property>
-                                      </packing>
-                                    </child>
-                                    <child>
-                                      <object class="GtkBox" id="hbox4">
-                                        <property name="visible">True</property>
-                                        <property name="can_focus">False</property>
-                                        <property name="spacing">6</property>
-                                        <child>
-                                          <object class="GtkScale" id="activate_delay_hscale">
-                                            <property name="visible">True</property>
-                                            <property name="can_focus">True</property>
-                                            <property name="adjustment">adjustment1</property>
-                                            <property name="digits">0</property>
-                                            <property name="value_pos">bottom</property>
-                                          </object>
-                                          <packing>
-                                            <property name="expand">True</property>
-                                            <property name="fill">True</property>
-                                            <property name="position">0</property>
-                                          </packing>
-                                        </child>
-                                      </object>
-                                      <packing>
-                                        <property name="expand">True</property>
-                                        <property name="fill">True</property>
-                                        <property name="position">1</property>
-                                      </packing>
-                                    </child>
-                                  </object>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="fill">True</property>
-                                    <property name="position">0</property>
-                                  </packing>
-                                </child>
-                                <child>
-                                  <object class="GtkCheckButton" id="enable_checkbox">
-                                    <property name="label" translatable="yes">_Activate screensaver when computer is idle</property>
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="use_underline">True</property>
-                                    <property name="draw_indicator">True</property>
-                                  </object>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="fill">False</property>
-                                    <property name="position">1</property>
-                                  </packing>
-                                </child>
-                                <child>
-                                  <object class="GtkCheckButton" id="lock_checkbox">
-                                    <property name="label" translatable="yes">_Lock screen when screensaver is active</property>
-                                    <property name="visible">True</property>
-                                    <property name="can_focus">True</property>
-                                    <property name="receives_default">False</property>
-                                    <property name="use_underline">True</property>
-                                    <property name="draw_indicator">True</property>
-                                  </object>
-                                  <packing>
-                                    <property name="expand">False</property>
-                                    <property name="fill">False</property>
-                                    <property name="position">2</property>
-                                  </packing>
-                                </child>
-                              </object>
-                              <packing>
-                                <property name="expand">True</property>
-                                <property name="fill">True</property>
-                                <property name="position">0</property>
-                              </packing>
-                            </child>
+                            <property name="label" translatable="yes">Enable Lock Screen</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
                           </object>
                           <packing>
-                            <property name="expand">True</property>
+                            <property name="expand">False</property>
                             <property name="fill">True</property>
                             <property name="position">0</property>
                           </packing>
                         </child>
+                        <child>
+                          <object class="GtkSwitch" id="enable_screenlocker">
+                            <property name="visible">True</property>
+                            <property name="sensitive">False</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="active">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="pack_type">end</property>
+                            <property name="position">1</property>
+                          </packing>
+                        </child>
                       </object>
                       <packing>
-                        <property name="expand">True</property>
+                        <property name="expand">False</property>
                         <property name="fill">True</property>
                         <property name="position">0</property>
                       </packing>
                     </child>
+                    <child>
+                      <object class="GtkGrid" id="screenlocker_grid">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="row_spacing">6</property>
+                        <property name="column_spacing">6</property>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="hexpand">True</property>
+                            <property name="label" translatable="yes">Session Status Messages</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">4</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="label" translatable="yes">User Switching</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">8</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="label" translatable="yes">Logout</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">5</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="logout_command_label">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_left">12</property>
+                            <property name="label" translatable="yes">Logout command:</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">6</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="logout_delay_label_left">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_left">12</property>
+                            <property name="label" translatable="yes">Enable logout after:</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">7</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="user_switch_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">8</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="logout_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">5</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="status_message_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">4</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="logout_command">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">6</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSpinButton" id="logout_delay">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="adjustment">adjustment4</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">7</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="logout_delay_label_right">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="label" translatable="yes">minutes</property>
+                            <attributes>
+                              <attribute name="style" value="italic"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">7</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="lock_delay_label_right">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="label" translatable="yes">minutes</property>
+                            <attributes>
+                              <attribute name="style" value="italic"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSpinButton" id="lock_delay">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="adjustment">adjustment3</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="lock_delay_label_left">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_left">12</property>
+                            <property name="label" translatable="yes">Lock the screen after the screensaver is active for:</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">1</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="lock_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">0</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="label" translatable="yes">Lock Screen with Screensaver</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">0</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_top">12</property>
+                            <property name="label" translatable="yes">On Screen Keyboard</property>
+                            <property name="xalign">0</property>
+                            <attributes>
+                              <attribute name="weight" value="bold"/>
+                            </attributes>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">2</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkSwitch" id="keyboard_enabled">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="halign">end</property>
+                            <property name="valign">center</property>
+                            <property name="margin_top">12</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">2</property>
+                            <property name="top_attach">2</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkLabel" id="keyboard_command_label">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <property name="margin_left">12</property>
+                            <property name="label" translatable="yes">On screen keyboard command:</property>
+                            <property name="xalign">0</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">0</property>
+                            <property name="top_attach">3</property>
+                          </packing>
+                        </child>
+                        <child>
+                          <object class="GtkEntry" id="keyboard_command">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                          </object>
+                          <packing>
+                            <property name="left_attach">1</property>
+                            <property name="top_attach">3</property>
+                            <property name="width">2</property>
+                          </packing>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
                   </object>
                   <packing>
-                    <property name="expand">True</property>
-                    <property name="fill">True</property>
-                    <property name="position">0</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child type="tab">
+                  <object class="GtkLabel">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="label" translatable="yes">Lock Screen</property>
+                  </object>
+                  <packing>
+                    <property name="position">1</property>
+                    <property name="tab_fill">False</property>
                   </packing>
                 </child>
+                <child>
+                  <placeholder/>
+                </child>
+                <child type="tab">
+                  <placeholder/>
+                </child>
               </object>
               <packing>
-                <property name="expand">False</property>
+                <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">3</property>
+                <property name="position">4</property>
               </packing>
             </child>
           </object>

-- 
To stop receiving notification emails like this one, please contact
the administrator of this repository.


More information about the Xfce4-commits mailing list