diff options
Diffstat (limited to 'src/mate-screensaver-preferences.c.orig')
| -rw-r--r-- | src/mate-screensaver-preferences.c.orig | 1781 |
1 files changed, 1781 insertions, 0 deletions
diff --git a/src/mate-screensaver-preferences.c.orig b/src/mate-screensaver-preferences.c.orig new file mode 100644 index 0000000..cedce78 --- /dev/null +++ b/src/mate-screensaver-preferences.c.orig @@ -0,0 +1,1781 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann <[email protected]> + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + * + * Authors: William Jon McCann <[email protected]> + * Rodrigo Moya <[email protected]> + * + */ + +#include "config.h" + +#define _GNU_SOURCE +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> /* For uid_t, gid_t */ + +#include <glib/gi18n.h> +#include <gdk/gdkx.h> +#include <gtk/gtk.h> +#include <mateconf/mateconf-client.h> + +#include <gio/gio.h> + +#include "copy-theme-dialog.h" + +#include "gs-theme-manager.h" +#include "gs-job.h" +#include "gs-prefs.h" /* for GS_MODE enum */ + +#define GTK_BUILDER_FILE "mate-screensaver-preferences.ui" + +#define MATE_LOCKDOWN_DIR "/desktop/mate/lockdown" +#define KEY_LOCK_DISABLE MATE_LOCKDOWN_DIR "/disable_lock_screen" + +#define KEY_DIR "/apps/mate-screensaver" +#define MATE_SESSION_DIR "/desktop/mate/session" +#define KEY_LOCK KEY_DIR "/lock_enabled" +#define KEY_IDLE_ACTIVATION_ENABLED KEY_DIR "/idle_activation_enabled" +#define KEY_MODE KEY_DIR "/mode" +#define KEY_ACTIVATE_DELAY MATE_SESSION_DIR "/idle_delay" +#define KEY_LOCK_DELAY KEY_DIR "/lock_delay" +#define KEY_CYCLE_DELAY KEY_DIR "/cycle_delay" +#define KEY_THEMES KEY_DIR "/themes" + +#define GPM_COMMAND "mate-power-preferences" + +enum +{ + NAME_COLUMN = 0, + ID_COLUMN, + N_COLUMNS +}; + +static MateConfEnumStringPair mode_enum_map [] = +{ + { GS_MODE_BLANK_ONLY, "blank-only" }, + { GS_MODE_RANDOM, "random" }, + { GS_MODE_SINGLE, "single" }, + { 0, NULL } +}; + +/* Drag and drop info */ +enum +{ + TARGET_URI_LIST, + TARGET_NS_URL +}; + +static GtkTargetEntry drop_types [] = +{ + { "text/uri-list", 0, TARGET_URI_LIST }, + { "_NETSCAPE_URL", 0, TARGET_NS_URL } +}; + +static GtkBuilder *builder = NULL; +static GSThemeManager *theme_manager = NULL; +static GSJob *job = NULL; + +static gint32 +config_get_activate_delay (gboolean *is_writable) +{ + MateConfClient *client; + gint32 delay; + + client = mateconf_client_get_default (); + + if (is_writable) + { + *is_writable = mateconf_client_key_is_writable (client, + KEY_ACTIVATE_DELAY, + NULL); + } + + delay = mateconf_client_get_int (client, KEY_ACTIVATE_DELAY, NULL); + + if (delay < 1) + { + delay = 1; + } + + g_object_unref (client); + + return delay; +} + +static void +config_set_activate_delay (gint32 timeout) +{ + MateConfClient *client; + + client = mateconf_client_get_default (); + + mateconf_client_set_int (client, KEY_ACTIVATE_DELAY, timeout, NULL); + + g_object_unref (client); +} + +static int +config_get_mode (gboolean *is_writable) +{ + MateConfClient *client; + int mode; + char *string; + + client = mateconf_client_get_default (); + + if (is_writable) + { + *is_writable = mateconf_client_key_is_writable (client, + KEY_MODE, + NULL); + } + + string = mateconf_client_get_string (client, KEY_MODE, NULL); + if (string) + { + mateconf_string_to_enum (mode_enum_map, string, &mode); + g_free (string); + } + else + { + mode = GS_MODE_BLANK_ONLY; + } + + g_object_unref (client); + + return mode; +} + +static void +config_set_mode (int mode) +{ + MateConfClient *client; + const char *mode_string; + + client = mateconf_client_get_default (); + + mode_string = mateconf_enum_to_string (mode_enum_map, mode); + mateconf_client_set_string (client, KEY_MODE, mode_string, NULL); + + g_object_unref (client); +} + +static char * +config_get_theme (gboolean *is_writable) +{ + MateConfClient *client; + char *name; + int mode; + + client = mateconf_client_get_default (); + + if (is_writable) + { + gboolean can_write_theme; + gboolean can_write_mode; + + can_write_theme = mateconf_client_key_is_writable (client, + KEY_THEMES, + NULL); + can_write_mode = mateconf_client_key_is_writable (client, + KEY_MODE, + NULL); + *is_writable = can_write_theme && can_write_mode; + } + + mode = config_get_mode (NULL); + + name = NULL; + if (mode == GS_MODE_BLANK_ONLY) + { + name = g_strdup ("__blank-only"); + } + else if (mode == GS_MODE_RANDOM) + { + name = g_strdup ("__random"); + } + else + { + GSList *list; + list = mateconf_client_get_list (client, + KEY_THEMES, + MATECONF_VALUE_STRING, + NULL); + if (list != NULL) + { + name = g_strdup (list->data); + } + else + { + /* TODO: handle error */ + /* default to blank */ + name = g_strdup ("__blank-only"); + } + + g_slist_foreach (list, (GFunc)g_free, NULL); + g_slist_free (list); + } + + g_object_unref (client); + + return name; +} + +static GSList * +get_all_theme_ids (GSThemeManager *theme_manager) +{ + GSList *ids = NULL; + GSList *entries; + GSList *l; + + entries = gs_theme_manager_get_info_list (theme_manager); + for (l = entries; l; l = l->next) + { + GSThemeInfo *info = l->data; + + ids = g_slist_prepend (ids, g_strdup (gs_theme_info_get_id (info))); + gs_theme_info_unref (info); + } + g_slist_free (entries); + + return ids; +} + +static void +config_set_theme (const char *theme_id) +{ + MateConfClient *client; + GSList *list = NULL; + int mode; + + client = mateconf_client_get_default (); + + if (theme_id && strcmp (theme_id, "__blank-only") == 0) + { + mode = GS_MODE_BLANK_ONLY; + } + else if (theme_id && strcmp (theme_id, "__random") == 0) + { + mode = GS_MODE_RANDOM; + + /* set the themes key to contain all available screensavers */ + list = get_all_theme_ids (theme_manager); + } + else + { + mode = GS_MODE_SINGLE; + list = g_slist_append (list, g_strdup (theme_id)); + } + + config_set_mode (mode); + + mateconf_client_set_list (client, + KEY_THEMES, + MATECONF_VALUE_STRING, + list, + NULL); + + g_slist_foreach (list, (GFunc) g_free, NULL); + g_slist_free (list); + + g_object_unref (client); +} + +static gboolean +config_get_enabled (gboolean *is_writable) +{ + int enabled; + MateConfClient *client; + + client = mateconf_client_get_default (); + + if (is_writable) + { + *is_writable = mateconf_client_key_is_writable (client, + KEY_LOCK, + NULL); + } + + enabled = mateconf_client_get_bool (client, KEY_IDLE_ACTIVATION_ENABLED, NULL); + + g_object_unref (client); + + return enabled; +} + +static void +config_set_enabled (gboolean enabled) +{ + MateConfClient *client; + + client = mateconf_client_get_default (); + + mateconf_client_set_bool (client, KEY_IDLE_ACTIVATION_ENABLED, enabled, NULL); + + g_object_unref (client); +} + +static gboolean +config_get_lock (gboolean *is_writable) +{ + MateConfClient *client; + gboolean lock; + + client = mateconf_client_get_default (); + + if (is_writable) + { + *is_writable = mateconf_client_key_is_writable (client, + KEY_LOCK, + NULL); + } + + lock = mateconf_client_get_bool (client, KEY_LOCK, NULL); + + g_object_unref (client); + + return lock; +} + +static gboolean +config_get_lock_disabled () +{ + MateConfClient *client; + gboolean lock; + + client = mateconf_client_get_default (); + + lock = mateconf_client_get_bool (client, KEY_LOCK_DISABLE, NULL); + + g_object_unref (client); + return lock; +} + +static void +config_set_lock (gboolean lock) +{ + MateConfClient *client; + + client = mateconf_client_get_default (); + + mateconf_client_set_bool (client, KEY_LOCK, lock, NULL); + + g_object_unref (client); +} + +static void +preview_clear (GtkWidget *widget) +{ + GdkColor color = { 0, 0, 0 }; + + gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &color); + gdk_window_clear (widget->window); +} + +static void +job_set_theme (GSJob *job, + const char *theme) +{ + GSThemeInfo *info; + const char *command; + + command = NULL; + + info = gs_theme_manager_lookup_theme_info (theme_manager, theme); + if (info != NULL) + { + command = gs_theme_info_get_exec (info); + } + + gs_job_set_command (job, command); + + if (info != NULL) + { + gs_theme_info_unref (info); + } +} + +static void +preview_set_theme (GtkWidget *widget, + const char *theme, + const char *name) +{ + GtkWidget *label; + char *markup; + + if (job != NULL) + { + gs_job_stop (job); + } + + preview_clear (widget); + + label = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_theme_label")); + markup = g_markup_printf_escaped ("<i>%s</i>", name); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + + if ((theme && strcmp (theme, "__blank-only") == 0)) + { + + } + else if (theme && strcmp (theme, "__random") == 0) + { + GSList *themes; + + themes = get_all_theme_ids (theme_manager); + if (themes != NULL) + { + GSList *l; + gint32 i; + + i = g_random_int_range (0, g_slist_length (themes)); + l = g_slist_nth (themes, i); + + job_set_theme (job, (const char *) l->data); + g_slist_foreach (themes, (GFunc) g_free, NULL); + g_slist_free (themes); + + gs_job_start (job); + } + } + else + { + job_set_theme (job, theme); + gs_job_start (job); + } +} + +static void +help_display (void) +{ + GError *error = NULL; + char *command; + const char *lang; + char *uri = NULL; + GdkScreen *gscreen; + int i; + + const char * const * langs = g_get_language_names (); + + for (i = 0; langs[i] != NULL; i++) + { + lang = langs[i]; + if (strchr (lang, '.')) + { + continue; + } + + uri = g_build_filename (DATADIR, + "/mate/help/user-guide/", + lang, + "/user-guide.xml", + NULL); + + if (g_file_test (uri, G_FILE_TEST_EXISTS)) + { + break; + } + } + + command = g_strconcat ("mate-open ghelp://", + uri, + "?prefs-screensaver", + NULL); + gscreen = gdk_screen_get_default (); + gdk_spawn_command_line_on_screen (gscreen, command, &error); + + if (error != NULL) + { + GtkWidget *d; + + d = gtk_message_dialog_new (NULL, + GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + "%s", error->message); + gtk_dialog_run (GTK_DIALOG (d)); + gtk_widget_destroy (d); + g_error_free (error); + } + + g_free (command); + g_free (uri); +} + +static void +response_cb (GtkWidget *widget, + int response_id) +{ + + if (response_id == GTK_RESPONSE_HELP) + { + help_display (); + } + else if (response_id == GTK_RESPONSE_REJECT) + { + GError *error; + gboolean res; + + error = NULL; + + res = gdk_spawn_command_line_on_screen (gdk_screen_get_default (), + GPM_COMMAND, + &error); + if (! res) + { + g_warning ("Unable to start power management preferences: %s", error->message); + g_error_free (error); + } + } + else + { + gtk_widget_destroy (widget); + gtk_main_quit (); + } +} + +static GSList * +get_theme_info_list (void) +{ + return gs_theme_manager_get_info_list (theme_manager); +} + +static void +populate_model (GtkTreeStore *store) +{ + GtkTreeIter iter; + GSList *themes = NULL; + GSList *l; + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + NAME_COLUMN, _("Blank screen"), + ID_COLUMN, "__blank-only", + -1); + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + NAME_COLUMN, _("Random"), + ID_COLUMN, "__random", + -1); + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + NAME_COLUMN, NULL, + ID_COLUMN, "__separator", + -1); + + themes = get_theme_info_list (); + + if (themes == NULL) + { + return; + } + + for (l = themes; l; l = l->next) + { + const char *name; + const char *id; + GSThemeInfo *info = l->data; + + if (info == NULL) + { + continue; + } + + name = gs_theme_info_get_name (info); + id = gs_theme_info_get_id (info); + + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + NAME_COLUMN, name, + ID_COLUMN, id, + -1); + + gs_theme_info_unref (info); + } + + g_slist_free (themes); +} + +static void +tree_selection_previous (GtkTreeSelection *selection) +{ + GtkTreeIter iter; + GtkTreeModel *model; + GtkTreePath *path; + + if (! gtk_tree_selection_get_selected (selection, &model, &iter)) + { + return; + } + + path = gtk_tree_model_get_path (model, &iter); + if (gtk_tree_path_prev (path)) + { + gtk_tree_selection_select_path (selection, path); + } +} + +static void +tree_selection_next (GtkTreeSelection *selection) +{ + GtkTreeIter iter; + GtkTreeModel *model; + GtkTreePath *path; + + if (! gtk_tree_selection_get_selected (selection, &model, &iter)) + { + return; + } + + path = gtk_tree_model_get_path (model, &iter); + gtk_tree_path_next (path); + gtk_tree_selection_select_path (selection, path); +} + +static void +tree_selection_changed_cb (GtkTreeSelection *selection, + GtkWidget *preview) +{ + GtkTreeIter iter; + GtkTreeModel *model; + char *theme; + char *name; + + if (! gtk_tree_selection_get_selected (selection, &model, &iter)) + { + return; + } + + gtk_tree_model_get (model, &iter, ID_COLUMN, &theme, NAME_COLUMN, &name, -1); + + if (theme == NULL) + { + g_free (name); + return; + } + + preview_set_theme (preview, theme, name); + config_set_theme (theme); + + g_free (theme); + g_free (name); +} + +static void +activate_delay_value_changed_cb (GtkRange *range, + gpointer user_data) +{ + gdouble value; + + value = gtk_range_get_value (range); + config_set_activate_delay ((gint32)value); +} + +static int +compare_theme_names (char *name_a, + char *name_b, + char *id_a, + char *id_b) +{ + + if (id_a == NULL) + { + return 1; + } + else if (id_b == NULL) + { + return -1; + } + + if (strcmp (id_a, "__blank-only") == 0) + { + return -1; + } + else if (strcmp (id_b, "__blank-only") == 0) + { + return 1; + } + else if (strcmp (id_a, "__random") == 0) + { + return -1; + } + else if (strcmp (id_b, "__random") == 0) + { + return 1; + } + else if (strcmp (id_a, "__separator") == 0) + { + return -1; + } + else if (strcmp (id_b, "__separator") == 0) + { + return 1; + } + + if (name_a == NULL) + { + return 1; + } + else if (name_b == NULL) + { + return -1; + } + + return g_utf8_collate (name_a, name_b); +} + +static int +compare_theme (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer user_data) +{ + char *name_a; + char *name_b; + char *id_a; + char *id_b; + int result; + + gtk_tree_model_get (model, a, NAME_COLUMN, &name_a, -1); + gtk_tree_model_get (model, b, NAME_COLUMN, &name_b, -1); + gtk_tree_model_get (model, a, ID_COLUMN, &id_a, -1); + gtk_tree_model_get (model, b, ID_COLUMN, &id_b, -1); + + result = compare_theme_names (name_a, name_b, id_a, id_b); + + g_free (name_a); + g_free (name_b); + g_free (id_a); + g_free (id_b); + + return result; +} + +static gboolean +separator_func (GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data) +{ + int column = GPOINTER_TO_INT (data); + char *text; + + gtk_tree_model_get (model, iter, column, &text, -1); + + if (text != NULL && strcmp (text, "__separator") == 0) + { + return TRUE; + } + + g_free (text); + + return FALSE; +} + +static void +setup_treeview (GtkWidget *tree, + GtkWidget *preview) +{ + GtkTreeStore *store; + GtkTreeViewColumn *column; + GtkCellRenderer *renderer; + GtkTreeSelection *select; + + store = gtk_tree_store_new (N_COLUMNS, + G_TYPE_STRING, + G_TYPE_STRING); + populate_model (store); + + gtk_tree_view_set_model (GTK_TREE_VIEW (tree), + GTK_TREE_MODEL (store)); + + g_object_unref (store); + +#if GTK_CHECK_VERSION(2,10,0) + g_object_set (tree, "show-expanders", FALSE, NULL); +#endif + + renderer = gtk_cell_renderer_text_new (); + column = gtk_tree_view_column_new_with_attributes ("Name", renderer, + "text", NAME_COLUMN, + NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); + + gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN); + gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), + NAME_COLUMN, + compare_theme, + NULL, NULL); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), + NAME_COLUMN, + GTK_SORT_ASCENDING); + + gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (tree), + separator_func, + GINT_TO_POINTER (ID_COLUMN), + NULL); + + select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); + gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); + g_signal_connect (G_OBJECT (select), "changed", + G_CALLBACK (tree_selection_changed_cb), + preview); + +} + +static void +setup_treeview_selection (GtkWidget *tree) +{ + char *theme; + GtkTreeModel *model; + GtkTreeIter iter; + GtkTreePath *path = NULL; + gboolean is_writable; + + theme = config_get_theme (&is_writable); + + if (! is_writable) + { + gtk_widget_set_sensitive (tree, FALSE); + } + + model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree)); + + if (theme && gtk_tree_model_get_iter_first (model, &iter)) + { + + do + { + char *id; + gboolean found; + + gtk_tree_model_get (model, &iter, + ID_COLUMN, &id, -1); + found = (id && strcmp (id, theme) == 0); + g_free (id); + + if (found) + { + path = gtk_tree_model_get_path (model, &iter); + break; + } + + } + while (gtk_tree_model_iter_next (model, &iter)); + } + + if (path) + { + gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), + path, + NULL, + FALSE); + + gtk_tree_path_free (path); + } + + g_free (theme); +} + +static void +reload_themes (void) +{ + GtkWidget *treeview; + GtkTreeModel *model; + + treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); + model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); + gtk_tree_store_clear (GTK_TREE_STORE (model)); + populate_model (GTK_TREE_STORE (model)); + + gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), + GTK_TREE_MODEL (model)); +} + +static void +theme_copy_complete_cb (GtkWidget *dialog, gpointer user_data) +{ + reload_themes (); + gtk_widget_destroy (dialog); +} + +static void +theme_installer_run (GtkWidget *prefs_dialog, GList *files) +{ + GtkWidget *copy_dialog; + + copy_dialog = copy_theme_dialog_new (files); + g_list_foreach (files, (GFunc) (g_object_unref), NULL); + g_list_free (files); + + gtk_window_set_transient_for (GTK_WINDOW (copy_dialog), + GTK_WINDOW (prefs_dialog)); + gtk_window_set_icon_name (GTK_WINDOW (copy_dialog), + "preferences-desktop-screensaver"); + + g_signal_connect (copy_dialog, "complete", + G_CALLBACK (theme_copy_complete_cb), NULL); + + copy_theme_dialog_begin (COPY_THEME_DIALOG (copy_dialog)); +} + +/* Callback issued during drag movements */ +static gboolean +drag_motion_cb (GtkWidget *widget, + GdkDragContext *context, + int x, + int y, + guint time, + gpointer data) +{ + return FALSE; +} + +/* Callback issued during drag leaves */ +static void +drag_leave_cb (GtkWidget *widget, + GdkDragContext *context, + guint time, + gpointer data) +{ + gtk_widget_queue_draw (widget); +} + +/* GIO has no version of mate_vfs_uri_list_parse(), so copy from MateVFS + * and re-work to create GFiles. +**/ +static GList * +uri_list_parse (const gchar *uri_list) +{ + const gchar *p, *q; + gchar *retval; + GFile *file; + GList *result = NULL; + + g_return_val_if_fail (uri_list != NULL, NULL); + + p = uri_list; + + /* We don't actually try to validate the URI according to RFC + * 2396, or even check for allowed characters - we just ignore + * comments and trim whitespace off the ends. We also + * allow LF delimination as well as the specified CRLF. + */ + while (p != NULL) + { + if (*p != '#') + { + while (g_ascii_isspace (*p)) + p++; + + q = p; + while ((*q != '\0') + && (*q != '\n') + && (*q != '\r')) + q++; + + if (q > p) + { + q--; + while (q > p + && g_ascii_isspace (*q)) + q--; + + retval = g_malloc (q - p + 2); + strncpy (retval, p, q - p + 1); + retval[q - p + 1] = '\0'; + + file = g_file_new_for_uri (retval); + + g_free (retval); + + if (file != NULL) + result = g_list_prepend (result, file); + } + } + p = strchr (p, '\n'); + if (p != NULL) + p++; + } + + return g_list_reverse (result); +} + +/* Callback issued on actual drops. Attempts to load the file dropped. */ +static void +drag_data_received_cb (GtkWidget *widget, + GdkDragContext *context, + int x, + int y, + GtkSelectionData *selection_data, + guint info, + guint time, + gpointer data) +{ + GList *files; + + if (!(info == TARGET_URI_LIST || info == TARGET_NS_URL)) + return; + + files = uri_list_parse ((char *) selection_data->data); + if (files != NULL) + { + GtkWidget *prefs_dialog; + + prefs_dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog")); + theme_installer_run (prefs_dialog, files); + } +} + +/* Adapted from totem_time_to_string_text */ +static char * +time_to_string_text (long time) +{ + char *secs, *mins, *hours, *string; + int sec, min, hour; + + sec = time % 60; + time = time - sec; + min = (time % (60 * 60)) / 60; + time = time - (min * 60); + hour = time / (60 * 60); + + hours = g_strdup_printf (ngettext ("%d hour", + "%d hours", hour), hour); + + mins = g_strdup_printf (ngettext ("%d minute", + "%d minutes", min), min); + + secs = g_strdup_printf (ngettext ("%d second", + "%d seconds", sec), sec); + + 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); + } + } + else + { + /* seconds */ + string = g_strdup_printf (_("%s"), secs); + } + + g_free (hours); + g_free (mins); + g_free (secs); + + return string; +} + +static char * +format_value_callback_time (GtkScale *scale, + gdouble value) +{ + if (value == 0) + return g_strdup_printf (_("Never")); + + return time_to_string_text (value * 60.0); +} + +static void +lock_checkbox_toggled (GtkToggleButton *button, gpointer user_data) +{ + config_set_lock (gtk_toggle_button_get_active (button)); +} + +static void +enabled_checkbox_toggled (GtkToggleButton *button, gpointer user_data) +{ + config_set_enabled (gtk_toggle_button_get_active (button)); +} + +static void +invalid_type_warning (const char *type) +{ + g_warning ("Error retrieving configuration key '%s': Invalid type", + type); +} + +static void +ui_disable_lock (gboolean disable) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox")); + gtk_widget_set_sensitive (widget, !disable); + if (disable) + { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); + } +} + +static void +ui_set_lock (gboolean enabled) +{ + GtkWidget *widget; + gboolean active; + gboolean lock_disabled; + + widget = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox")); + + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); + if (active != enabled) + { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), enabled); + } + lock_disabled = config_get_lock_disabled (); + ui_disable_lock (lock_disabled); +} + +static void +ui_set_enabled (gboolean enabled) +{ + GtkWidget *widget; + gboolean active; + gboolean is_writable; + gboolean lock_disabled; + + widget = GTK_WIDGET (gtk_builder_get_object (builder, "enable_checkbox")); + active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); + if (active != enabled) + { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (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); + } + lock_disabled = config_get_lock_disabled (); + ui_disable_lock(lock_disabled); +} + +static void +ui_set_delay (int delay) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (gtk_builder_get_object (builder, "activate_delay_hscale")); + gtk_range_set_value (GTK_RANGE (widget), delay); +} + +static void +key_changed_cb (MateConfClient *client, + guint cnxn_id, + MateConfEntry *entry, + gpointer data) +{ + const char *key; + MateConfValue *value; + + key = mateconf_entry_get_key (entry); + + if (! g_str_has_prefix (key, KEY_DIR) && ! g_str_has_prefix (key, MATE_LOCKDOWN_DIR)) + { + return; + } + + value = mateconf_entry_get_value (entry); + + if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0) + { + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + + ui_set_enabled (enabled); + } + else + { + invalid_type_warning (key); + } + } + else if (strcmp (key, KEY_LOCK) == 0) + { + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + + ui_set_lock (enabled); + } + else + { + invalid_type_warning (key); + } + } + else if (strcmp (key, KEY_LOCK_DISABLE) == 0) + { + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean disabled; + + disabled = mateconf_value_get_bool (value); + + ui_disable_lock (disabled); + } + else + { + invalid_type_warning (key); + } + } + else if (strcmp (key, KEY_THEMES) == 0) + { + if (value->type == MATECONF_VALUE_LIST) + { + GtkWidget *treeview; + + treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); + setup_treeview_selection (treeview); + } + else + { + invalid_type_warning (key); + } + } + else if (strcmp (key, KEY_ACTIVATE_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + ui_set_delay (delay); + } + else + { + invalid_type_warning (key); + } + + } + else + { + /*g_warning ("Config key not handled: %s", key);*/ + } +} + +static void +fullscreen_preview_previous_cb (GtkWidget *fullscreen_preview_window, + gpointer user_data) +{ + GtkWidget *treeview; + GtkTreeSelection *selection; + + treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); + tree_selection_previous (selection); +} + +static void +fullscreen_preview_next_cb (GtkWidget *fullscreen_preview_window, + gpointer user_data) +{ + GtkWidget *treeview; + GtkTreeSelection *selection; + + treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); + tree_selection_next (selection); +} + +static void +fullscreen_preview_cancelled_cb (GtkWidget *button, + gpointer user_data) +{ + + GtkWidget *fullscreen_preview_area; + GtkWidget *fullscreen_preview_window; + GtkWidget *preview_area; + GtkWidget *dialog; + + preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area")); + gs_job_set_widget (job, preview_area); + + fullscreen_preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_area")); + preview_clear (fullscreen_preview_area); + + fullscreen_preview_window = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_window")); + gtk_widget_hide (fullscreen_preview_window); + + dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog")); + gtk_widget_show (dialog); + gtk_window_present (GTK_WINDOW (dialog)); +} + +static void +fullscreen_preview_start_cb (GtkWidget *widget, + gpointer user_data) +{ + GtkWidget *fullscreen_preview_area; + GtkWidget *fullscreen_preview_window; + GtkWidget *dialog; + + dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog")); + gtk_widget_hide (dialog); + + fullscreen_preview_window = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_window")); + + gtk_window_fullscreen (GTK_WINDOW (fullscreen_preview_window)); + gtk_window_set_keep_above (GTK_WINDOW (fullscreen_preview_window), TRUE); + + gtk_widget_show (fullscreen_preview_window); + gtk_widget_grab_focus (fullscreen_preview_window); + + fullscreen_preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_area")); + preview_clear (fullscreen_preview_area); + gs_job_set_widget (job, fullscreen_preview_area); +} + +static void +constrain_list_size (GtkWidget *widget, + GtkRequisition *requisition, + GtkWidget *to_size) +{ + GtkRequisition req; + int max_height; + + /* constrain height to be the tree height up to a max */ + max_height = (gdk_screen_get_height (gtk_widget_get_screen (widget))) / 4; + + gtk_widget_size_request (to_size, &req); + + requisition->height = MIN (req.height, max_height); +} + +static void +setup_list_size_constraint (GtkWidget *widget, + GtkWidget *to_size) +{ + g_signal_connect (widget, "size-request", + G_CALLBACK (constrain_list_size), to_size); +} + +static gboolean +check_is_root_user (void) +{ +#ifndef G_OS_WIN32 + uid_t ruid, euid, suid; /* Real, effective and saved user ID's */ + gid_t rgid, egid, sgid; /* Real, effective and saved group ID's */ + +#ifdef HAVE_GETRESUID + if (getresuid (&ruid, &euid, &suid) != 0 || + getresgid (&rgid, &egid, &sgid) != 0) +#endif /* HAVE_GETRESUID */ + { + suid = ruid = getuid (); + sgid = rgid = getgid (); + euid = geteuid (); + egid = getegid (); + } + + if (ruid == 0) + { + return TRUE; + } + +#endif + return FALSE; +} + +static void +setup_for_root_user (void) +{ + GtkWidget *lock_checkbox; + GtkWidget *label; + + lock_checkbox = GTK_WIDGET (gtk_builder_get_object (builder, "lock_checkbox")); + label = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_label")); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (lock_checkbox), FALSE); + gtk_widget_set_sensitive (lock_checkbox, FALSE); + + gtk_widget_show (label); +} + +static GdkVisual * +get_best_visual (void) +{ + char *command; + char *std_output; + int exit_status; + GError *error; + unsigned long v; + char c; + GdkVisual *visual; + gboolean res; + + visual = NULL; + + command = g_build_filename (LIBEXECDIR, "mate-screensaver-gl-helper", NULL); + + error = NULL; + res = g_spawn_command_line_sync (command, + &std_output, + NULL, + &exit_status, + &error); + + if (! res) + { + g_debug ("Could not run command '%s': %s", command, error->message); + g_error_free (error); + goto out; + } + + if (1 == sscanf (std_output, "0x%lx %c", &v, &c)) + { + if (v != 0) + { + VisualID visual_id; + + visual_id = (VisualID) v; + visual = gdkx_visual_get (visual_id); + + g_debug ("Found best visual for GL: 0x%x", + (unsigned int) visual_id); + } + } + +out: + g_free (std_output); + g_free (command); + + return visual; +} + +static GdkColormap * +get_best_colormap_for_screen (GdkScreen *screen) +{ + GdkColormap *colormap; + GdkVisual *visual; + + g_return_val_if_fail (screen != NULL, NULL); + + visual = get_best_visual (); + + colormap = NULL; + if (visual != NULL) + { + colormap = gdk_colormap_new (visual, FALSE); + } + + return colormap; +} + +static void +widget_set_best_colormap (GtkWidget *widget) +{ + GdkColormap *colormap; + + g_return_if_fail (widget != NULL); + + colormap = get_best_colormap_for_screen (gtk_widget_get_screen (widget)); + if (colormap != NULL) + { + gtk_widget_set_colormap (widget, colormap); + g_object_unref (colormap); + } +} + +static gboolean +setup_treeview_idle (gpointer data) +{ + GtkWidget *preview; + GtkWidget *treeview; + + preview = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area")); + treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview")); + + setup_treeview (treeview, preview); + setup_treeview_selection (treeview); + + return FALSE; +} + +static gboolean +is_program_in_path (const char *program) +{ + char *tmp = g_find_program_in_path (program); + if (tmp != NULL) + { + g_free (tmp); + return TRUE; + } + else + { + return FALSE; + } +} + +static void +init_capplet (void) +{ + GtkWidget *dialog; + 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_label; + GtkWidget *preview_button; + GtkWidget *gpm_button; + GtkWidget *fullscreen_preview_window; + GtkWidget *fullscreen_preview_previous; + GtkWidget *fullscreen_preview_next; + GtkWidget *fullscreen_preview_area; + GtkWidget *fullscreen_preview_close; + char *gtk_builder_file; + char *string; + gdouble activate_delay; + gboolean enabled; + gboolean is_writable; + MateConfClient *client; + GError *error=NULL; + + gtk_builder_file = g_build_filename (GTKBUILDERDIR, GTK_BUILDER_FILE, NULL); + builder = gtk_builder_new(); + if (!gtk_builder_add_from_file(builder, gtk_builder_file, &error)) + { + g_warning("Couldn't load builder file: %s", error->message); + g_error_free(error); + } + g_free (gtk_builder_file); + + if (builder == NULL) + { + + dialog = gtk_message_dialog_new (NULL, + 0, GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + _("Could not load the main interface")); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("Please make sure that the screensaver is properly installed")); + + gtk_dialog_set_default_response (GTK_DIALOG (dialog), + GTK_RESPONSE_OK); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + exit (1); + } + + preview = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area")); + dialog = GTK_WIDGET (gtk_builder_get_object (builder, "prefs_dialog")); + 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_label = GTK_WIDGET (gtk_builder_get_object (builder, "root_warning_label")); + preview_button = GTK_WIDGET (gtk_builder_get_object (builder, "preview_button")); + gpm_button = GTK_WIDGET (gtk_builder_get_object (builder, "gpm_button")); + fullscreen_preview_window = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_window")); + fullscreen_preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_area")); + fullscreen_preview_close = GTK_WIDGET (gtk_builder_get_object (builder, "fullscreen_preview_close")); + 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_label, TRUE); + widget_set_best_colormap (preview); + + if (! is_program_in_path (GPM_COMMAND)) + { + gtk_widget_set_no_show_all (gpm_button, TRUE); + gtk_widget_hide (gpm_button); + } + + 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); + + 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); + + 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); + + setup_list_size_constraint (list_scroller, treeview); + gtk_widget_set_size_request (preview, 480, 300); + gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver"); + gtk_window_set_icon_name (GTK_WINDOW (fullscreen_preview_window), "screensaver"); + + gtk_drag_dest_set (dialog, GTK_DEST_DEFAULT_ALL, + drop_types, G_N_ELEMENTS (drop_types), + GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE); + + g_signal_connect (dialog, "drag-motion", + G_CALLBACK (drag_motion_cb), NULL); + g_signal_connect (dialog, "drag-leave", + G_CALLBACK (drag_leave_cb), NULL); + g_signal_connect (dialog, "drag-data-received", + G_CALLBACK (drag_data_received_cb), NULL); + + gtk_widget_show_all (dialog); + + /* Update list of themes if using random screensaver */ + client = mateconf_client_get_default (); + string = mateconf_client_get_string (client, KEY_MODE, NULL); + if (string != NULL) + { + int mode; + GSList *list; + + mateconf_string_to_enum (mode_enum_map, string, &mode); + g_free (string); + + if (mode == GS_MODE_RANDOM) + { + list = get_all_theme_ids (theme_manager); + mateconf_client_set_list (client, KEY_THEMES, MATECONF_VALUE_STRING, list, NULL); + + g_slist_foreach (list, (GFunc) g_free, NULL); + g_slist_free (list); + } + } + + mateconf_client_add_dir (client, KEY_DIR, + MATECONF_CLIENT_PRELOAD_ONELEVEL, + NULL); + mateconf_client_notify_add (client, + KEY_DIR, + key_changed_cb, + NULL, NULL, NULL); + mateconf_client_add_dir (client, MATE_LOCKDOWN_DIR, + MATECONF_CLIENT_PRELOAD_ONELEVEL, + NULL); + mateconf_client_notify_add (client, + MATE_LOCKDOWN_DIR, + key_changed_cb, + NULL, NULL, NULL); + + g_object_unref (client); + + preview_clear (preview); + gs_job_set_widget (job, preview); + + if (check_is_root_user ()) + { + setup_for_root_user (); + } + + g_signal_connect (activate_delay_hscale, "value-changed", + G_CALLBACK (activate_delay_value_changed_cb), NULL); + + g_signal_connect (dialog, "response", + G_CALLBACK (response_cb), NULL); + + g_signal_connect (preview_button, "clicked", + G_CALLBACK (fullscreen_preview_start_cb), + treeview); + + g_signal_connect (fullscreen_preview_close, "clicked", + G_CALLBACK (fullscreen_preview_cancelled_cb), NULL); + g_signal_connect (fullscreen_preview_previous, "clicked", + G_CALLBACK (fullscreen_preview_previous_cb), NULL); + g_signal_connect (fullscreen_preview_next, "clicked", + G_CALLBACK (fullscreen_preview_next_cb), NULL); + + g_idle_add ((GSourceFunc)setup_treeview_idle, NULL); +} + +int +main (int argc, + char **argv) +{ + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + gtk_init (&argc, &argv); + + job = gs_job_new (); + theme_manager = gs_theme_manager_new (); + + init_capplet (); + + gtk_main (); + + g_object_unref (theme_manager); + g_object_unref (job); + + return 0; +} |