From fff4ecc82f2bcfa7427596e7ad9c3769fcab040b Mon Sep 17 00:00:00 2001 From: Perberos Date: Fri, 4 Nov 2011 22:16:15 -0300 Subject: first commit --- src/Makefile.am | 268 ++++ src/copy-theme-dialog.c | 545 +++++++ src/copy-theme-dialog.c.orig | 545 +++++++ src/copy-theme-dialog.h | 56 + src/copy-theme-dialog.h.orig | 56 + src/debug-screensaver.sh | 42 + src/gs-auth-helper.c | 213 +++ src/gs-auth-helper.c.orig | 213 +++ src/gs-auth-pam.c | 843 ++++++++++ src/gs-auth-pam.c.orig | 843 ++++++++++ src/gs-auth-pwent.c | 291 ++++ src/gs-auth-pwent.c.orig | 291 ++++ src/gs-auth.h | 67 + src/gs-auth.h.orig | 65 + src/gs-debug.c | 163 ++ src/gs-debug.c.orig | 163 ++ src/gs-debug.h | 71 + src/gs-fade.c | 987 ++++++++++++ src/gs-fade.c.orig | 987 ++++++++++++ src/gs-fade.h | 77 + src/gs-fade.h.orig | 77 + src/gs-grab-x11.c | 672 ++++++++ src/gs-grab-x11.c.orig | 672 ++++++++ src/gs-grab.h | 79 + src/gs-grab.h.orig | 79 + src/gs-job.c | 567 +++++++ src/gs-job.c.orig | 567 +++++++ src/gs-job.h | 69 + src/gs-job.h.orig | 69 + src/gs-listener-dbus.c | 2272 ++++++++++++++++++++++++++ src/gs-listener-dbus.c.orig | 2272 ++++++++++++++++++++++++++ src/gs-listener-dbus.h | 89 ++ src/gs-listener-dbus.h.orig | 89 ++ src/gs-lock-plug.c | 2050 ++++++++++++++++++++++++ src/gs-lock-plug.c.orig | 2050 ++++++++++++++++++++++++ src/gs-lock-plug.h | 82 + src/gs-lock-plug.h.orig | 82 + src/gs-manager.c | 2030 ++++++++++++++++++++++++ src/gs-manager.c.orig | 2030 ++++++++++++++++++++++++ src/gs-manager.h | 107 ++ src/gs-manager.h.orig | 107 ++ src/gs-marshal.list | 4 + src/gs-monitor.c | 528 ++++++ src/gs-monitor.c.orig | 528 ++++++ src/gs-monitor.h | 57 + src/gs-monitor.h.orig | 57 + src/gs-prefs.c | 995 ++++++++++++ src/gs-prefs.c.orig | 995 ++++++++++++ src/gs-prefs.h | 85 + src/gs-prefs.h.orig | 85 + src/gs-theme-manager.c | 453 ++++++ src/gs-theme-manager.c.orig | 453 ++++++ src/gs-theme-manager.h | 65 + src/gs-theme-manager.h.orig | 65 + src/gs-visual-gl.c | 116 ++ src/gs-visual-gl.c.orig | 116 ++ src/gs-visual-gl.h | 32 + src/gs-watcher-x11.c | 680 ++++++++ src/gs-watcher-x11.c.orig | 680 ++++++++ src/gs-watcher.h | 65 + src/gs-watcher.h.orig | 65 + src/gs-window-x11.c | 2647 +++++++++++++++++++++++++++++++ src/gs-window-x11.c.orig | 2647 +++++++++++++++++++++++++++++++ src/gs-window.h | 106 ++ src/gs-window.h.orig | 106 ++ src/mate-screensaver-command.c | 551 +++++++ src/mate-screensaver-command.c.orig | 551 +++++++ src/mate-screensaver-dialog.c | 665 ++++++++ src/mate-screensaver-dialog.c.orig | 665 ++++++++ src/mate-screensaver-gl-helper.c | 83 + src/mate-screensaver-gl-helper.c.orig | 83 + src/mate-screensaver-preferences.c | 1781 +++++++++++++++++++++ src/mate-screensaver-preferences.c.orig | 1781 +++++++++++++++++++++ src/mate-screensaver.c | 132 ++ src/mate-screensaver.c.orig | 132 ++ src/mate-screensaver.desktop.in.in | 14 + src/mate-screensaver.h | 32 + src/setuid.c | 247 +++ src/setuid.c.orig | 247 +++ src/setuid.h | 25 + src/setuid.h.orig | 25 + src/subprocs.c | 166 ++ src/subprocs.c.orig | 166 ++ src/subprocs.h | 39 + src/subprocs.h.orig | 39 + src/test-fade.c | 134 ++ src/test-fade.c.orig | 134 ++ src/test-passwd.c | 288 ++++ src/test-passwd.c.orig | 288 ++++ src/test-watcher.c | 106 ++ src/test-watcher.c.orig | 106 ++ src/test-window.c | 180 +++ src/test-window.c.orig | 180 +++ 93 files changed, 43367 insertions(+) create mode 100644 src/Makefile.am create mode 100644 src/copy-theme-dialog.c create mode 100644 src/copy-theme-dialog.c.orig create mode 100644 src/copy-theme-dialog.h create mode 100644 src/copy-theme-dialog.h.orig create mode 100755 src/debug-screensaver.sh create mode 100644 src/gs-auth-helper.c create mode 100644 src/gs-auth-helper.c.orig create mode 100644 src/gs-auth-pam.c create mode 100644 src/gs-auth-pam.c.orig create mode 100644 src/gs-auth-pwent.c create mode 100644 src/gs-auth-pwent.c.orig create mode 100644 src/gs-auth.h create mode 100644 src/gs-auth.h.orig create mode 100644 src/gs-debug.c create mode 100644 src/gs-debug.c.orig create mode 100644 src/gs-debug.h create mode 100644 src/gs-fade.c create mode 100644 src/gs-fade.c.orig create mode 100644 src/gs-fade.h create mode 100644 src/gs-fade.h.orig create mode 100644 src/gs-grab-x11.c create mode 100644 src/gs-grab-x11.c.orig create mode 100644 src/gs-grab.h create mode 100644 src/gs-grab.h.orig create mode 100644 src/gs-job.c create mode 100644 src/gs-job.c.orig create mode 100644 src/gs-job.h create mode 100644 src/gs-job.h.orig create mode 100644 src/gs-listener-dbus.c create mode 100644 src/gs-listener-dbus.c.orig create mode 100644 src/gs-listener-dbus.h create mode 100644 src/gs-listener-dbus.h.orig create mode 100644 src/gs-lock-plug.c create mode 100644 src/gs-lock-plug.c.orig create mode 100644 src/gs-lock-plug.h create mode 100644 src/gs-lock-plug.h.orig create mode 100644 src/gs-manager.c create mode 100644 src/gs-manager.c.orig create mode 100644 src/gs-manager.h create mode 100644 src/gs-manager.h.orig create mode 100644 src/gs-marshal.list create mode 100644 src/gs-monitor.c create mode 100644 src/gs-monitor.c.orig create mode 100644 src/gs-monitor.h create mode 100644 src/gs-monitor.h.orig create mode 100644 src/gs-prefs.c create mode 100644 src/gs-prefs.c.orig create mode 100644 src/gs-prefs.h create mode 100644 src/gs-prefs.h.orig create mode 100644 src/gs-theme-manager.c create mode 100644 src/gs-theme-manager.c.orig create mode 100644 src/gs-theme-manager.h create mode 100644 src/gs-theme-manager.h.orig create mode 100644 src/gs-visual-gl.c create mode 100644 src/gs-visual-gl.c.orig create mode 100644 src/gs-visual-gl.h create mode 100644 src/gs-watcher-x11.c create mode 100644 src/gs-watcher-x11.c.orig create mode 100644 src/gs-watcher.h create mode 100644 src/gs-watcher.h.orig create mode 100644 src/gs-window-x11.c create mode 100644 src/gs-window-x11.c.orig create mode 100644 src/gs-window.h create mode 100644 src/gs-window.h.orig create mode 100644 src/mate-screensaver-command.c create mode 100644 src/mate-screensaver-command.c.orig create mode 100644 src/mate-screensaver-dialog.c create mode 100644 src/mate-screensaver-dialog.c.orig create mode 100644 src/mate-screensaver-gl-helper.c create mode 100644 src/mate-screensaver-gl-helper.c.orig create mode 100644 src/mate-screensaver-preferences.c create mode 100644 src/mate-screensaver-preferences.c.orig create mode 100644 src/mate-screensaver.c create mode 100644 src/mate-screensaver.c.orig create mode 100644 src/mate-screensaver.desktop.in.in create mode 100644 src/mate-screensaver.h create mode 100644 src/setuid.c create mode 100644 src/setuid.c.orig create mode 100644 src/setuid.h create mode 100644 src/setuid.h.orig create mode 100644 src/subprocs.c create mode 100644 src/subprocs.c.orig create mode 100644 src/subprocs.h create mode 100644 src/subprocs.h.orig create mode 100644 src/test-fade.c create mode 100644 src/test-fade.c.orig create mode 100644 src/test-passwd.c create mode 100644 src/test-passwd.c.orig create mode 100644 src/test-watcher.c create mode 100644 src/test-watcher.c.orig create mode 100644 src/test-window.c create mode 100644 src/test-window.c.orig (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..1de819f --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,268 @@ +## We require new-style dependency handling. +AUTOMAKE_OPTIONS = 1.7 + +NULL = + +saverdir = $(libexecdir)/mate-screensaver +themesdir = $(pkgdatadir)/themes + +INCLUDES = \ + -I. \ + -I$(srcdir) \ + -DMATEMENU_I_KNOW_THIS_IS_UNSTABLE \ + $(MATE_SCREENSAVER_CFLAGS) \ + $(MATE_SCREENSAVER_DIALOG_CFLAGS) \ + $(MATE_SCREENSAVER_CAPPLET_CFLAGS) \ + $(DISABLE_DEPRECATED_CFLAGS) \ + -DPREFIX=\""$(prefix)"\" \ + -DBINDIR=\""$(bindir)"\" \ + -DLIBDIR=\""$(libdir)"\" \ + -DLIBEXECDIR=\""$(libexecdir)"\" \ + -DDATADIR=\""$(datadir)"\" \ + -DSYSCONFDIR=\""$(sysconfdir)"\" \ + -DMATELOCALEDIR=\""$(datadir)/locale"\" \ + -DSAVERDIR=\""$(saverdir)"\" \ + -DTHEMESDIR=\""$(themesdir)"\" \ + -DGTKBUILDERDIR=\"$(pkgdatadir)\" \ + -DPAM_SERVICE_NAME=\""mate-screensaver"\" \ + $(WARN_CFLAGS) \ + $(AUTH_CFLAGS) \ + $(DEBUG_CFLAGS) \ + $(DBUS_CFLAGS) \ + $(LIBMATEKBDUI_CFLAGS) \ + $(LIBMATENOTIFY_CFLAGS) \ + $(NULL) + +bin_PROGRAMS = \ + mate-screensaver \ + mate-screensaver-command \ + mate-screensaver-preferences \ + $(NULL) + +libexec_PROGRAMS = \ + mate-screensaver-dialog \ + mate-screensaver-gl-helper \ + $(NULL) + +noinst_PROGRAMS = \ + test-fade \ + test-passwd \ + test-watcher \ + test-window \ + $(NULL) + +desktopdir = $(sysconfdir)/xdg/autostart +desktop_in_files = mate-screensaver.desktop.in +desktop_DATA = $(desktop_in_files:.desktop.in=.desktop) +@INTLTOOL_DESKTOP_RULE@ + +mate_screensaver_command_SOURCES = \ + mate-screensaver-command.c \ + $(NULL) + +mate_screensaver_command_LDADD = \ + $(MATE_SCREENSAVER_COMMAND_LIBS) \ + $(NULL) + +AUTH_SOURCES = \ + gs-auth.h \ + gs-auth-@AUTH_SCHEME@.c \ + $(NULL) + +test_fade_SOURCES = \ + test-fade.c \ + gs-fade.c \ + gs-fade.h \ + gs-debug.c \ + gs-debug.h \ + $(NULL) + +test_fade_LDADD = \ + $(MATE_SCREENSAVER_LIBS) \ + $(SAVER_LIBS) \ + $(NULL) + +test_passwd_SOURCES = \ + test-passwd.c \ + $(AUTH_SOURCES) \ + setuid.c \ + setuid.h \ + subprocs.c \ + subprocs.h \ + $(NULL) + +test_passwd_LDADD = \ + $(MATE_SCREENSAVER_DIALOG_LIBS)\ + $(AUTH_LIBS) \ + $(NULL) + +test_watcher_SOURCES = \ + test-watcher.c \ + gs-watcher.h \ + gs-watcher-x11.c \ + gs-marshal.c \ + gs-marshal.h \ + gs-debug.c \ + gs-debug.h \ + $(NULL) + +test_watcher_LDADD = \ + $(MATE_SCREENSAVER_LIBS) \ + $(SAVER_LIBS) \ + $(NULL) + +test_window_SOURCES = \ + test-window.c \ + gs-window.h \ + gs-window-x11.c \ + gs-grab-x11.c \ + gs-grab.h \ + gs-marshal.c \ + gs-marshal.h \ + gs-debug.c \ + gs-debug.h \ + subprocs.c \ + subprocs.h \ + $(NULL) + +test_window_LDADD = \ + $(MATE_SCREENSAVER_LIBS) \ + $(SAVER_LIBS) \ + $(NULL) + +mate_screensaver_dialog_SOURCES = \ + mate-screensaver-dialog.c \ + gs-lock-plug.c \ + gs-lock-plug.h \ + gs-debug.c \ + gs-debug.h \ + setuid.c \ + setuid.h \ + subprocs.c \ + subprocs.h \ + $(AUTH_SOURCES) \ + $(NULL) + +EXTRA_mate_screensaver_dialog_SOURCES = \ + gs-auth-pam.c \ + gs-auth-helper.c \ + gs-auth-pwent.c \ + $(NULL) + +mate_screensaver_dialog_LDADD = \ + $(MATE_SCREENSAVER_DIALOG_LIBS)\ + $(SAVER_LIBS) \ + $(AUTH_LIBS) \ + $(LIBMATEKBDUI_LIBS) \ + $(LIBMATENOTIFY_LIBS) \ + $(NULL) + +BUILT_SOURCES = \ + gs-marshal.c \ + gs-marshal.h \ + $(NULL) + +gs-marshal.c: gs-marshal.list + echo "#include \"gs-marshal.h\"" > $@ && \ + @GLIB_GENMARSHAL@ $< --prefix=gs_marshal --body >> $@ + +gs-marshal.h: gs-marshal.list + @GLIB_GENMARSHAL@ $< --prefix=gs_marshal --header > $@ + +mate_screensaver_SOURCES = \ + mate-screensaver.c \ + mate-screensaver.h \ + gs-monitor.c \ + gs-monitor.h \ + gs-watcher-x11.c \ + gs-watcher.h \ + gs-listener-dbus.c \ + gs-listener-dbus.h \ + gs-manager.c \ + gs-manager.h \ + gs-window-x11.c \ + gs-window.h \ + gs-prefs.c \ + gs-prefs.h \ + gs-theme-manager.c \ + gs-theme-manager.h \ + gs-job.c \ + gs-job.h \ + gs-debug.c \ + gs-debug.h \ + subprocs.c \ + subprocs.h \ + gs-grab-x11.c \ + gs-grab.h \ + gs-fade.c \ + gs-fade.h \ + $(BUILT_SOURCES) \ + $(NULL) + +mate_screensaver_gl_helper_LDADD = \ + $(MATE_SCREENSAVER_LIBS) \ + $(GL_LIBS) \ + $(NULL) + +mate_screensaver_gl_helper_SOURCES = \ + mate-screensaver-gl-helper.c \ + gs-visual-gl.c \ + gs-visual-gl.h \ + $(NULL) + +mate_screensaver_LDADD = \ + $(MATE_SCREENSAVER_LIBS) \ + $(SAVER_LIBS) \ + $(NULL) + +mate_screensaver_LDFLAGS = -export-dynamic + +mate_screensaver_preferences_SOURCES = \ + mate-screensaver-preferences.c \ + copy-theme-dialog.c \ + copy-theme-dialog.h \ + gs-theme-manager.c \ + gs-theme-manager.h \ + gs-job.c \ + gs-job.h \ + gs-debug.c \ + gs-debug.h \ + subprocs.c \ + subprocs.h \ + $(NULL) + +mate_screensaver_preferences_LDADD = \ + $(MATE_SCREENSAVER_CAPPLET_LIBS) \ + $(NULL) + +EXTRA_DIST = \ + debug-screensaver.sh \ + gs-marshal.list \ + mate-screensaver.desktop.in \ + $(NULL) + +CLEANFILES = \ + $(desktop_DATA) \ + mate-screensaver.desktop.in \ + $(BUILT_SOURCES) + +MAINTAINERCLEANFILES = \ + *~ \ + Makefile.in + +install-exec-hook: + @if [ "x@NEED_SETUID@" = "xyes" ]; then \ + echo "***" ; \ + echo "*** Warning: mate-screensaver has been compiled with support for" ; \ + echo "*** shadow passwords. If your system actually uses shadow" ; \ + echo "*** passwords then it must be installed as a setuid root" ; \ + echo "*** program in order for locking to work. To do this, you" ; \ + echo "*** must run:" ; \ + echo "***" ; \ + echo "*** chown root $(DESTDIR)$(libexecdir)/mate-screensaver-dialog" ; \ + echo "*** chmod +s $(DESTDIR)$(libexecdir)/mate-screensaver-dialog" ; \ + echo "***" ; \ + echo "*** For now, it will be installed non-setuid, which" ; \ + echo "*** means that locking might not work." ; \ + echo "***" ; \ + fi diff --git a/src/copy-theme-dialog.c b/src/copy-theme-dialog.c new file mode 100644 index 0000000..ed7808d --- /dev/null +++ b/src/copy-theme-dialog.c @@ -0,0 +1,545 @@ +/* copy-theme-dialog.c + * Copyright (C) 2008 John Millikin + * + * 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, 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. +**/ + +#include "config.h" + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "copy-theme-dialog.h" + +static void +copy_theme_dialog_class_init (CopyThemeDialogClass *klass); +static void +copy_theme_dialog_init (CopyThemeDialog *dlg); +static void +add_file_to_dialog (gpointer data, gpointer user_data); +static void +single_copy_complete (GObject *source_object, GAsyncResult *res, + gpointer user_data); +static void +copy_theme_dialog_copy_next (CopyThemeDialog *dialog); +static void +copy_theme_dialog_cancel (CopyThemeDialog *dialog); +static void +copy_theme_dialog_finalize (GObject *obj); +static void +copy_theme_dialog_update_num_files (CopyThemeDialog *dlg); +static void +copy_theme_dialog_response (GtkDialog *dialog, gint response_id); +static void +eel_gtk_label_make_bold (GtkLabel *label); +static void +create_titled_label (GtkTable *table, + int row, + GtkWidget **title_widget, + GtkWidget **label_text_widget); + +static GObjectClass *parent_class = NULL; + +enum +{ + CANCELLED = 0, + COMPLETE, + SIGNAL_COUNT +}; + +struct _CopyThemeDialogPrivate +{ + GtkWidget *progress; + GtkWidget *status; + GtkWidget *current; + GtkWidget *from; + GtkWidget *to; + + GFile *theme_dir; + GSList *all_files, *file; + GSList *all_basenames, *basename; + guint index; + guint total_files; + GCancellable *cancellable; +}; + +guint signals[SIGNAL_COUNT] = {0, 0}; + +GType +copy_theme_dialog_get_type (void) +{ + static GType copy_theme_dialog_type = 0; + + if (!copy_theme_dialog_type) + { + static GTypeInfo copy_theme_dialog_info = + { + sizeof (CopyThemeDialogClass), + NULL, /* GBaseInitFunc */ + NULL, /* GBaseFinalizeFunc */ + (GClassInitFunc) copy_theme_dialog_class_init, + NULL, /* GClassFinalizeFunc */ + NULL, /* data */ + sizeof (CopyThemeDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) copy_theme_dialog_init, + NULL + }; + + copy_theme_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, + "CopyThemeDialog", + ©_theme_dialog_info, + 0); + } + + return copy_theme_dialog_type; +} + +static void +copy_theme_dialog_class_init (CopyThemeDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (klass, sizeof (CopyThemeDialogPrivate)); + + klass->cancelled = copy_theme_dialog_cancel; + object_class->finalize = copy_theme_dialog_finalize; + + GTK_DIALOG_CLASS (klass)->response = copy_theme_dialog_response; + + signals[CANCELLED] = g_signal_new ("cancelled", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (CopyThemeDialogClass, cancelled), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + signals[COMPLETE] = g_signal_new ("complete", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (CopyThemeDialogClass, complete), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + parent_class = g_type_class_peek_parent (klass); +} + +GtkWidget* +copy_theme_dialog_new (GList *files) +{ + GtkWidget *dialog; + CopyThemeDialogPrivate *priv; + + dialog = GTK_WIDGET (g_object_new (COPY_THEME_DIALOG_TYPE, NULL)); + priv = COPY_THEME_DIALOG (dialog)->priv; + priv->index = 0; + priv->total_files = 0; + priv->all_files = NULL; + priv->all_basenames = NULL; + + g_list_foreach (files, add_file_to_dialog, dialog); + + priv->file = priv->all_files; + priv->basename = priv->all_basenames; + + return dialog; +} + +static gboolean +copy_finished (CopyThemeDialog *dialog) +{ + return (g_cancellable_is_cancelled (dialog->priv->cancellable) || + dialog->priv->file == NULL); +} + +static void +copy_theme_dialog_init (CopyThemeDialog *dlg) +{ + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *progress_vbox; + GtkWidget *table; + GtkWidget *label; + char *markup; + gchar *theme_dir_path; + + dlg->priv = G_TYPE_INSTANCE_GET_PRIVATE (dlg, COPY_THEME_DIALOG_TYPE, + CopyThemeDialogPrivate); + + /* Find and, if needed, create the directory for storing themes */ + theme_dir_path = g_build_filename (g_get_user_data_dir (), + "applications", "screensavers", + NULL); + dlg->priv->theme_dir = g_file_new_for_path (theme_dir_path); + g_mkdir_with_parents (theme_dir_path, S_IRWXU); + g_free (theme_dir_path); + + /* For cancelling async I/O operations */ + dlg->priv->cancellable = g_cancellable_new (); + + /* GUI settings */ + gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), + 4); + gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dlg)->vbox), 4); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0); + + dlg->priv->status = gtk_label_new (""); + markup = g_strdup_printf ("%s", _("Copying files")); + gtk_label_set_markup (GTK_LABEL (dlg->priv->status), markup); + g_free (markup); + + gtk_misc_set_alignment (GTK_MISC (dlg->priv->status), 0.0, 0.0); + + gtk_box_pack_start (GTK_BOX (vbox), dlg->priv->status, FALSE, FALSE, 0); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); + + table = gtk_table_new (2, 2, FALSE); + gtk_table_set_row_spacings (GTK_TABLE (table), 4); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + + create_titled_label (GTK_TABLE (table), 0, + &label, + &dlg->priv->from); + gtk_label_set_text (GTK_LABEL (label), _("From:")); + create_titled_label (GTK_TABLE (table), 1, + &label, + &dlg->priv->to); + gtk_label_set_text (GTK_LABEL (label), _("To:")); + + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (table), FALSE, FALSE, 0); + + progress_vbox = gtk_vbox_new (TRUE, 0); + gtk_box_pack_start (GTK_BOX (vbox), progress_vbox, FALSE, FALSE, 0); + + dlg->priv->progress = gtk_progress_bar_new (); + gtk_box_pack_start (GTK_BOX (progress_vbox), + dlg->priv->progress, FALSE, FALSE, 0); + + dlg->priv->current = gtk_label_new (""); + gtk_box_pack_start (GTK_BOX (progress_vbox), + dlg->priv->current, FALSE, FALSE, 0); + gtk_misc_set_alignment (GTK_MISC (dlg->priv->current), 0.0, 0.5); + + gtk_dialog_add_button (GTK_DIALOG (dlg), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); + + gtk_window_set_title (GTK_WINDOW (dlg), + _("Copying themes")); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (dlg), 6); + + gtk_widget_show_all (GTK_DIALOG (dlg)->vbox); +} + +static void +add_file_to_dialog (gpointer data, gpointer user_data) +{ + CopyThemeDialogPrivate *priv; + GFile *file; + gchar *basename = NULL, *raw_basename; + + priv = COPY_THEME_DIALOG (user_data)->priv; + file = G_FILE (data); + + raw_basename = g_file_get_basename (file); + if (g_str_has_suffix (raw_basename, ".desktop")) + { + /* FIXME: validate key file? */ + basename = g_strndup (raw_basename, + /* 8 = strlen (".desktop") */ + strlen (raw_basename) - 8); + } + g_free (raw_basename); + + if (basename) + { + g_object_ref (file); + priv->all_files = g_slist_append (priv->all_files, file); + priv->all_basenames = g_slist_append (priv->all_basenames, basename); + priv->total_files++; + } + + else + { + GtkWidget *dialog; + gchar *uri; + + dialog = gtk_message_dialog_new (GTK_WINDOW (user_data), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + _("Invalid screensaver theme")); + uri = g_file_get_uri (file); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("%s does not appear to be a valid screensaver theme."), + uri); + g_free (uri); + gtk_window_set_title (GTK_WINDOW (dialog), ""); + gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +single_copy_complete (GObject *source_object, GAsyncResult *res, + gpointer user_data) +{ + GError *error = NULL; + gboolean should_continue = FALSE; + CopyThemeDialog *dialog = COPY_THEME_DIALOG (user_data); + + if (g_file_copy_finish (G_FILE (source_object), res, &error)) + { + should_continue = TRUE; + } + + else + { + /* If the file already exists, generate a new random name + * and try again. + **/ + if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) + { + GFile *file, *destination; + gchar *basename, *full_basename; + g_error_free (error); + + file = G_FILE (dialog->priv->file->data); + basename = (gchar *) (dialog->priv->basename->data); + + g_return_if_fail (file != NULL); + g_return_if_fail (basename != NULL); + + full_basename = g_strdup_printf ("%s-%u.desktop", + basename, + g_random_int ()); + destination = g_file_get_child (dialog->priv->theme_dir, + full_basename); + g_free (full_basename); + + g_file_copy_async (file, destination, G_FILE_COPY_NONE, + G_PRIORITY_DEFAULT, + dialog->priv->cancellable, + NULL, NULL, + single_copy_complete, dialog); + } + + else + { + if (g_error_matches (error, G_IO_ERROR, + G_IO_ERROR_CANCELLED)) + { + /* User has cancelled the theme copy */ + g_signal_emit (G_OBJECT (dialog), + signals[CANCELLED], + 0, NULL); + } + + else + { + /* Some other error occurred, ignore and + * try to copy remaining files + **/ + should_continue = TRUE; + } + + g_error_free (error); + } + } + + /* Update informational widgets and, if needed, signal + * copy completion. + **/ + if (should_continue) + { + dialog->priv->index++; + dialog->priv->file = dialog->priv->file->next; + dialog->priv->basename = dialog->priv->basename->next; + copy_theme_dialog_update_num_files (dialog); + copy_theme_dialog_copy_next (dialog); + } +} + +/* Try to copy the theme file to the user's screensaver directory. + * If a file with the given name already exists, the error will be + * caught later and the copy re-attempted with a random value + * appended to the filename. +**/ +static void +copy_theme_dialog_copy_next (CopyThemeDialog *dialog) +{ + GFile *file, *destination; + gchar *basename, *full_basename; + + if (copy_finished (dialog)) + { + g_signal_emit (G_OBJECT (dialog), signals[COMPLETE], + 0, NULL); + return; + } + + file = G_FILE (dialog->priv->file->data); + basename = (gchar *) (dialog->priv->basename->data); + + g_return_if_fail (file != NULL); + g_return_if_fail (basename != NULL); + + full_basename = g_strdup_printf ("%s.desktop", basename); + destination = g_file_get_child (dialog->priv->theme_dir, full_basename); + g_free (full_basename); + + g_file_copy_async (file, destination, G_FILE_COPY_NONE, + G_PRIORITY_DEFAULT, dialog->priv->cancellable, + NULL, NULL, single_copy_complete, dialog); +} + +static gboolean +timeout_display_dialog (gpointer data) +{ + if (IS_COPY_THEME_DIALOG (data)) + { + CopyThemeDialog *dialog = COPY_THEME_DIALOG (data); + if (!copy_finished (dialog)) + { + gtk_widget_show (GTK_WIDGET (dialog)); + + g_signal_connect (dialog, "response", + G_CALLBACK (copy_theme_dialog_response), + dialog); + } + } + return FALSE; +} + +void +copy_theme_dialog_begin (CopyThemeDialog *dialog) +{ + gtk_widget_hide (GTK_WIDGET (dialog)); + + /* If the copy operation takes more than half a second to + * complete, display the dialog. + **/ + g_timeout_add (500, timeout_display_dialog, dialog); + + copy_theme_dialog_copy_next (dialog); +} + +static void +copy_theme_dialog_cancel (CopyThemeDialog *dialog) +{ + g_cancellable_cancel (dialog->priv->cancellable); +} + +static void +copy_theme_dialog_finalize (GObject *obj) +{ + CopyThemeDialog *dlg = COPY_THEME_DIALOG (obj); + + g_object_unref (dlg->priv->theme_dir); + g_slist_foreach (dlg->priv->all_files, (GFunc) (g_object_unref), NULL); + g_slist_free (dlg->priv->all_files); + g_slist_foreach (dlg->priv->all_basenames, (GFunc) (g_free), NULL); + g_slist_free (dlg->priv->all_basenames); + g_object_unref (dlg->priv->cancellable); + + if (parent_class->finalize) + parent_class->finalize (G_OBJECT (dlg)); +} + +static void +copy_theme_dialog_update_num_files (CopyThemeDialog *dlg) +{ + gchar *str = g_strdup_printf (_("Copying file: %u of %u"), + dlg->priv->index, dlg->priv->total_files); + gtk_progress_bar_set_text (GTK_PROGRESS_BAR (dlg->priv->progress), str); + g_free (str); +} + +static void +copy_theme_dialog_response (GtkDialog *dialog, gint response_id) +{ + g_cancellable_cancel (COPY_THEME_DIALOG (dialog)->priv->cancellable); +} + +/** + * eel_gtk_label_make_bold. + * + * Switches the font of label to a bold equivalent. + * @label: The label. + **/ +static void +eel_gtk_label_make_bold (GtkLabel *label) +{ + PangoFontDescription *font_desc; + + font_desc = pango_font_description_new (); + + pango_font_description_set_weight (font_desc, + PANGO_WEIGHT_BOLD); + + /* This will only affect the weight of the font, the rest is + * from the current state of the widget, which comes from the + * theme or user prefs, since the font desc only has the + * weight flag turned on. + */ + gtk_widget_modify_font (GTK_WIDGET (label), font_desc); + + pango_font_description_free (font_desc); +} + +/* from caja */ +static void +create_titled_label (GtkTable *table, + int row, + GtkWidget **title_widget, + GtkWidget **label_text_widget) +{ + *title_widget = gtk_label_new (""); + eel_gtk_label_make_bold (GTK_LABEL (*title_widget)); + gtk_misc_set_alignment (GTK_MISC (*title_widget), 1, 0); + gtk_table_attach (table, *title_widget, + 0, 1, + row, row + 1, + GTK_FILL, 0, + 0, 0); + gtk_widget_show (*title_widget); + + *label_text_widget = gtk_label_new (""); + gtk_label_set_ellipsize (GTK_LABEL (*label_text_widget), PANGO_ELLIPSIZE_END); + gtk_table_attach (table, *label_text_widget, + 1, 2, + row, row + 1, + GTK_FILL | GTK_EXPAND, 0, + 0, 0); + gtk_widget_show (*label_text_widget); + gtk_misc_set_alignment (GTK_MISC (*label_text_widget), 0, 0); +} diff --git a/src/copy-theme-dialog.c.orig b/src/copy-theme-dialog.c.orig new file mode 100644 index 0000000..d8150eb --- /dev/null +++ b/src/copy-theme-dialog.c.orig @@ -0,0 +1,545 @@ +/* copy-theme-dialog.c + * Copyright (C) 2008 John Millikin + * + * 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, 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. +**/ + +#include "config.h" + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "copy-theme-dialog.h" + +static void +copy_theme_dialog_class_init (CopyThemeDialogClass *klass); +static void +copy_theme_dialog_init (CopyThemeDialog *dlg); +static void +add_file_to_dialog (gpointer data, gpointer user_data); +static void +single_copy_complete (GObject *source_object, GAsyncResult *res, + gpointer user_data); +static void +copy_theme_dialog_copy_next (CopyThemeDialog *dialog); +static void +copy_theme_dialog_cancel (CopyThemeDialog *dialog); +static void +copy_theme_dialog_finalize (GObject *obj); +static void +copy_theme_dialog_update_num_files (CopyThemeDialog *dlg); +static void +copy_theme_dialog_response (GtkDialog *dialog, gint response_id); +static void +eel_gtk_label_make_bold (GtkLabel *label); +static void +create_titled_label (GtkTable *table, + int row, + GtkWidget **title_widget, + GtkWidget **label_text_widget); + +static GObjectClass *parent_class = NULL; + +enum +{ + CANCELLED = 0, + COMPLETE, + SIGNAL_COUNT +}; + +struct _CopyThemeDialogPrivate +{ + GtkWidget *progress; + GtkWidget *status; + GtkWidget *current; + GtkWidget *from; + GtkWidget *to; + + GFile *theme_dir; + GSList *all_files, *file; + GSList *all_basenames, *basename; + guint index; + guint total_files; + GCancellable *cancellable; +}; + +guint signals[SIGNAL_COUNT] = {0, 0}; + +GType +copy_theme_dialog_get_type (void) +{ + static GType copy_theme_dialog_type = 0; + + if (!copy_theme_dialog_type) + { + static GTypeInfo copy_theme_dialog_info = + { + sizeof (CopyThemeDialogClass), + NULL, /* GBaseInitFunc */ + NULL, /* GBaseFinalizeFunc */ + (GClassInitFunc) copy_theme_dialog_class_init, + NULL, /* GClassFinalizeFunc */ + NULL, /* data */ + sizeof (CopyThemeDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) copy_theme_dialog_init, + NULL + }; + + copy_theme_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, + "CopyThemeDialog", + ©_theme_dialog_info, + 0); + } + + return copy_theme_dialog_type; +} + +static void +copy_theme_dialog_class_init (CopyThemeDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + g_type_class_add_private (klass, sizeof (CopyThemeDialogPrivate)); + + klass->cancelled = copy_theme_dialog_cancel; + object_class->finalize = copy_theme_dialog_finalize; + + GTK_DIALOG_CLASS (klass)->response = copy_theme_dialog_response; + + signals[CANCELLED] = g_signal_new ("cancelled", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (CopyThemeDialogClass, cancelled), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + signals[COMPLETE] = g_signal_new ("complete", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (CopyThemeDialogClass, complete), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + parent_class = g_type_class_peek_parent (klass); +} + +GtkWidget* +copy_theme_dialog_new (GList *files) +{ + GtkWidget *dialog; + CopyThemeDialogPrivate *priv; + + dialog = GTK_WIDGET (g_object_new (COPY_THEME_DIALOG_TYPE, NULL)); + priv = COPY_THEME_DIALOG (dialog)->priv; + priv->index = 0; + priv->total_files = 0; + priv->all_files = NULL; + priv->all_basenames = NULL; + + g_list_foreach (files, add_file_to_dialog, dialog); + + priv->file = priv->all_files; + priv->basename = priv->all_basenames; + + return dialog; +} + +static gboolean +copy_finished (CopyThemeDialog *dialog) +{ + return (g_cancellable_is_cancelled (dialog->priv->cancellable) || + dialog->priv->file == NULL); +} + +static void +copy_theme_dialog_init (CopyThemeDialog *dlg) +{ + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *progress_vbox; + GtkWidget *table; + GtkWidget *label; + char *markup; + gchar *theme_dir_path; + + dlg->priv = G_TYPE_INSTANCE_GET_PRIVATE (dlg, COPY_THEME_DIALOG_TYPE, + CopyThemeDialogPrivate); + + /* Find and, if needed, create the directory for storing themes */ + theme_dir_path = g_build_filename (g_get_user_data_dir (), + "applications", "screensavers", + NULL); + dlg->priv->theme_dir = g_file_new_for_path (theme_dir_path); + g_mkdir_with_parents (theme_dir_path, S_IRWXU); + g_free (theme_dir_path); + + /* For cancelling async I/O operations */ + dlg->priv->cancellable = g_cancellable_new (); + + /* GUI settings */ + gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), + 4); + gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dlg)->vbox), 4); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0); + + dlg->priv->status = gtk_label_new (""); + markup = g_strdup_printf ("%s", _("Copying files")); + gtk_label_set_markup (GTK_LABEL (dlg->priv->status), markup); + g_free (markup); + + gtk_misc_set_alignment (GTK_MISC (dlg->priv->status), 0.0, 0.0); + + gtk_box_pack_start (GTK_BOX (vbox), dlg->priv->status, FALSE, FALSE, 0); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); + + table = gtk_table_new (2, 2, FALSE); + gtk_table_set_row_spacings (GTK_TABLE (table), 4); + gtk_table_set_col_spacings (GTK_TABLE (table), 4); + + create_titled_label (GTK_TABLE (table), 0, + &label, + &dlg->priv->from); + gtk_label_set_text (GTK_LABEL (label), _("From:")); + create_titled_label (GTK_TABLE (table), 1, + &label, + &dlg->priv->to); + gtk_label_set_text (GTK_LABEL (label), _("To:")); + + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (table), FALSE, FALSE, 0); + + progress_vbox = gtk_vbox_new (TRUE, 0); + gtk_box_pack_start (GTK_BOX (vbox), progress_vbox, FALSE, FALSE, 0); + + dlg->priv->progress = gtk_progress_bar_new (); + gtk_box_pack_start (GTK_BOX (progress_vbox), + dlg->priv->progress, FALSE, FALSE, 0); + + dlg->priv->current = gtk_label_new (""); + gtk_box_pack_start (GTK_BOX (progress_vbox), + dlg->priv->current, FALSE, FALSE, 0); + gtk_misc_set_alignment (GTK_MISC (dlg->priv->current), 0.0, 0.5); + + gtk_dialog_add_button (GTK_DIALOG (dlg), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); + + gtk_window_set_title (GTK_WINDOW (dlg), + _("Copying themes")); + gtk_dialog_set_has_separator (GTK_DIALOG (dlg), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (dlg), 6); + + gtk_widget_show_all (GTK_DIALOG (dlg)->vbox); +} + +static void +add_file_to_dialog (gpointer data, gpointer user_data) +{ + CopyThemeDialogPrivate *priv; + GFile *file; + gchar *basename = NULL, *raw_basename; + + priv = COPY_THEME_DIALOG (user_data)->priv; + file = G_FILE (data); + + raw_basename = g_file_get_basename (file); + if (g_str_has_suffix (raw_basename, ".desktop")) + { + /* FIXME: validate key file? */ + basename = g_strndup (raw_basename, + /* 8 = strlen (".desktop") */ + strlen (raw_basename) - 8); + } + g_free (raw_basename); + + if (basename) + { + g_object_ref (file); + priv->all_files = g_slist_append (priv->all_files, file); + priv->all_basenames = g_slist_append (priv->all_basenames, basename); + priv->total_files++; + } + + else + { + GtkWidget *dialog; + gchar *uri; + + dialog = gtk_message_dialog_new (GTK_WINDOW (user_data), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + _("Invalid screensaver theme")); + uri = g_file_get_uri (file); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("%s does not appear to be a valid screensaver theme."), + uri); + g_free (uri); + gtk_window_set_title (GTK_WINDOW (dialog), ""); + gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-desktop-screensaver"); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } +} + +static void +single_copy_complete (GObject *source_object, GAsyncResult *res, + gpointer user_data) +{ + GError *error = NULL; + gboolean should_continue = FALSE; + CopyThemeDialog *dialog = COPY_THEME_DIALOG (user_data); + + if (g_file_copy_finish (G_FILE (source_object), res, &error)) + { + should_continue = TRUE; + } + + else + { + /* If the file already exists, generate a new random name + * and try again. + **/ + if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) + { + GFile *file, *destination; + gchar *basename, *full_basename; + g_error_free (error); + + file = G_FILE (dialog->priv->file->data); + basename = (gchar *) (dialog->priv->basename->data); + + g_return_if_fail (file != NULL); + g_return_if_fail (basename != NULL); + + full_basename = g_strdup_printf ("%s-%u.desktop", + basename, + g_random_int ()); + destination = g_file_get_child (dialog->priv->theme_dir, + full_basename); + g_free (full_basename); + + g_file_copy_async (file, destination, G_FILE_COPY_NONE, + G_PRIORITY_DEFAULT, + dialog->priv->cancellable, + NULL, NULL, + single_copy_complete, dialog); + } + + else + { + if (g_error_matches (error, G_IO_ERROR, + G_IO_ERROR_CANCELLED)) + { + /* User has cancelled the theme copy */ + g_signal_emit (G_OBJECT (dialog), + signals[CANCELLED], + 0, NULL); + } + + else + { + /* Some other error occurred, ignore and + * try to copy remaining files + **/ + should_continue = TRUE; + } + + g_error_free (error); + } + } + + /* Update informational widgets and, if needed, signal + * copy completion. + **/ + if (should_continue) + { + dialog->priv->index++; + dialog->priv->file = dialog->priv->file->next; + dialog->priv->basename = dialog->priv->basename->next; + copy_theme_dialog_update_num_files (dialog); + copy_theme_dialog_copy_next (dialog); + } +} + +/* Try to copy the theme file to the user's screensaver directory. + * If a file with the given name already exists, the error will be + * caught later and the copy re-attempted with a random value + * appended to the filename. +**/ +static void +copy_theme_dialog_copy_next (CopyThemeDialog *dialog) +{ + GFile *file, *destination; + gchar *basename, *full_basename; + + if (copy_finished (dialog)) + { + g_signal_emit (G_OBJECT (dialog), signals[COMPLETE], + 0, NULL); + return; + } + + file = G_FILE (dialog->priv->file->data); + basename = (gchar *) (dialog->priv->basename->data); + + g_return_if_fail (file != NULL); + g_return_if_fail (basename != NULL); + + full_basename = g_strdup_printf ("%s.desktop", basename); + destination = g_file_get_child (dialog->priv->theme_dir, full_basename); + g_free (full_basename); + + g_file_copy_async (file, destination, G_FILE_COPY_NONE, + G_PRIORITY_DEFAULT, dialog->priv->cancellable, + NULL, NULL, single_copy_complete, dialog); +} + +static gboolean +timeout_display_dialog (gpointer data) +{ + if (IS_COPY_THEME_DIALOG (data)) + { + CopyThemeDialog *dialog = COPY_THEME_DIALOG (data); + if (!copy_finished (dialog)) + { + gtk_widget_show (GTK_WIDGET (dialog)); + + g_signal_connect (dialog, "response", + G_CALLBACK (copy_theme_dialog_response), + dialog); + } + } + return FALSE; +} + +void +copy_theme_dialog_begin (CopyThemeDialog *dialog) +{ + gtk_widget_hide (GTK_WIDGET (dialog)); + + /* If the copy operation takes more than half a second to + * complete, display the dialog. + **/ + g_timeout_add (500, timeout_display_dialog, dialog); + + copy_theme_dialog_copy_next (dialog); +} + +static void +copy_theme_dialog_cancel (CopyThemeDialog *dialog) +{ + g_cancellable_cancel (dialog->priv->cancellable); +} + +static void +copy_theme_dialog_finalize (GObject *obj) +{ + CopyThemeDialog *dlg = COPY_THEME_DIALOG (obj); + + g_object_unref (dlg->priv->theme_dir); + g_slist_foreach (dlg->priv->all_files, (GFunc) (g_object_unref), NULL); + g_slist_free (dlg->priv->all_files); + g_slist_foreach (dlg->priv->all_basenames, (GFunc) (g_free), NULL); + g_slist_free (dlg->priv->all_basenames); + g_object_unref (dlg->priv->cancellable); + + if (parent_class->finalize) + parent_class->finalize (G_OBJECT (dlg)); +} + +static void +copy_theme_dialog_update_num_files (CopyThemeDialog *dlg) +{ + gchar *str = g_strdup_printf (_("Copying file: %u of %u"), + dlg->priv->index, dlg->priv->total_files); + gtk_progress_bar_set_text (GTK_PROGRESS_BAR (dlg->priv->progress), str); + g_free (str); +} + +static void +copy_theme_dialog_response (GtkDialog *dialog, gint response_id) +{ + g_cancellable_cancel (COPY_THEME_DIALOG (dialog)->priv->cancellable); +} + +/** + * eel_gtk_label_make_bold. + * + * Switches the font of label to a bold equivalent. + * @label: The label. + **/ +static void +eel_gtk_label_make_bold (GtkLabel *label) +{ + PangoFontDescription *font_desc; + + font_desc = pango_font_description_new (); + + pango_font_description_set_weight (font_desc, + PANGO_WEIGHT_BOLD); + + /* This will only affect the weight of the font, the rest is + * from the current state of the widget, which comes from the + * theme or user prefs, since the font desc only has the + * weight flag turned on. + */ + gtk_widget_modify_font (GTK_WIDGET (label), font_desc); + + pango_font_description_free (font_desc); +} + +/* from caja */ +static void +create_titled_label (GtkTable *table, + int row, + GtkWidget **title_widget, + GtkWidget **label_text_widget) +{ + *title_widget = gtk_label_new (""); + eel_gtk_label_make_bold (GTK_LABEL (*title_widget)); + gtk_misc_set_alignment (GTK_MISC (*title_widget), 1, 0); + gtk_table_attach (table, *title_widget, + 0, 1, + row, row + 1, + GTK_FILL, 0, + 0, 0); + gtk_widget_show (*title_widget); + + *label_text_widget = gtk_label_new (""); + gtk_label_set_ellipsize (GTK_LABEL (*label_text_widget), PANGO_ELLIPSIZE_END); + gtk_table_attach (table, *label_text_widget, + 1, 2, + row, row + 1, + GTK_FILL | GTK_EXPAND, 0, + 0, 0); + gtk_widget_show (*label_text_widget); + gtk_misc_set_alignment (GTK_MISC (*label_text_widget), 0, 0); +} diff --git a/src/copy-theme-dialog.h b/src/copy-theme-dialog.h new file mode 100644 index 0000000..6e72017 --- /dev/null +++ b/src/copy-theme-dialog.h @@ -0,0 +1,56 @@ +/* copy-theme-dialog.h + * Copyright (C) 2008 John Millikin + * + * 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, 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. +**/ + +#ifndef __COPY_THEME_DIALOG_H__ +#define __COPY_THEME_DIALOG_H__ + +#include + +G_BEGIN_DECLS + +#define COPY_THEME_DIALOG_TYPE copy_theme_dialog_get_type () +#define COPY_THEME_DIALOG(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, COPY_THEME_DIALOG_TYPE, CopyThemeDialog) +#define COPY_THEME_DIALOG_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, COPY_THEME_DIALOG_TYPE, CopyThemeDialogClass) +#define IS_COPY_THEME_DIALOG(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, COPY_THEME_DIALOG_TYPE) + +typedef struct _CopyThemeDialog CopyThemeDialog; +typedef struct _CopyThemeDialogClass CopyThemeDialogClass; +typedef struct _CopyThemeDialogPrivate CopyThemeDialogPrivate; + +struct _CopyThemeDialog +{ + GtkDialog dialog; + CopyThemeDialogPrivate *priv; +}; + +struct _CopyThemeDialogClass +{ + GtkDialogClass parent_class; + + void (*cancelled) (CopyThemeDialog *dialog); + void (*complete) (CopyThemeDialog *dialog); +}; + +GType copy_theme_dialog_get_type (void); +GtkWidget *copy_theme_dialog_new (GList *files); +void copy_theme_dialog_begin (CopyThemeDialog *dialog); + +G_END_DECLS + +#endif /* __COPY_THEME_DIALOG_H__ */ diff --git a/src/copy-theme-dialog.h.orig b/src/copy-theme-dialog.h.orig new file mode 100644 index 0000000..b1e66fd --- /dev/null +++ b/src/copy-theme-dialog.h.orig @@ -0,0 +1,56 @@ +/* copy-theme-dialog.h + * Copyright (C) 2008 John Millikin + * + * 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, 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. +**/ + +#ifndef __COPY_THEME_DIALOG_H__ +#define __COPY_THEME_DIALOG_H__ + +#include + +G_BEGIN_DECLS + +#define COPY_THEME_DIALOG_TYPE copy_theme_dialog_get_type () +#define COPY_THEME_DIALOG(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, COPY_THEME_DIALOG_TYPE, CopyThemeDialog) +#define COPY_THEME_DIALOG_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, COPY_THEME_DIALOG_TYPE, CopyThemeDialogClass) +#define IS_COPY_THEME_DIALOG(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, COPY_THEME_DIALOG_TYPE) + +typedef struct _CopyThemeDialog CopyThemeDialog; +typedef struct _CopyThemeDialogClass CopyThemeDialogClass; +typedef struct _CopyThemeDialogPrivate CopyThemeDialogPrivate; + +struct _CopyThemeDialog +{ + GtkDialog dialog; + CopyThemeDialogPrivate *priv; +}; + +struct _CopyThemeDialogClass +{ + GtkDialogClass parent_class; + + void (*cancelled) (CopyThemeDialog *dialog); + void (*complete) (CopyThemeDialog *dialog); +}; + +GType copy_theme_dialog_get_type (void); +GtkWidget *copy_theme_dialog_new (GList *files); +void copy_theme_dialog_begin (CopyThemeDialog *dialog); + +G_END_DECLS + +#endif /* __COPY_THEME_DIALOG_H__ */ diff --git a/src/debug-screensaver.sh b/src/debug-screensaver.sh new file mode 100755 index 0000000..c8b1a93 --- /dev/null +++ b/src/debug-screensaver.sh @@ -0,0 +1,42 @@ +#!/bin/sh + +# This is probably linux only at the moment + +if [ -z "${DBUS_SESSION_BUS_ADDRESS}" ]; then + pid=`pgrep -u $USER "mate-session|x-session-manager"` + if [ "x$pid" != "x" ]; then + env_address=`(cat /proc/$pid/environ; echo) | tr "\000" "\n" | grep '^DBUS_SESSION_BUS_ADDRESS='` + env_display=`(cat /proc/$pid/environ; echo) | tr "\000" "\n" | grep '^DISPLAY='` + env_xdg_cookie=`(cat /proc/$pid/environ; echo) | tr "\000" "\n" | grep '^XDG_SESSION_COOKIE='` + env_path=`(cat /proc/$pid/environ; echo) | tr "\000" "\n" | grep '^PATH='` + if [ "x$env_address" != "x" ]; then + echo "Setting $env_address" + echo "Setting $env_display" + echo "Setting $env_path" + echo "Setting $env_xdg_cookie" + eval "export $env_address" + eval "export $env_display" + eval "export $env_path" + eval "export $env_xdg_cookie" + fi + fi +fi + +if [ -z "${DBUS_SESSION_BUS_ADDRESS}" ]; then + echo "Could not determine DBUS_SESSION_BUS_ADDRESS" + exit 1 +fi + +export G_DEBUG=fatal_criticals + +# kill the existing daemon +mate-screensaver-command --exit + +# run the daemon in the debugger +#gdb --args mate-screensaver --no-daemon --debug --sync + +# or if that isn't helpful just get the debug output +#mate-screensaver --no-daemon --debug > /tmp/gs-debug-log.txt 2>&1 + +# or just run it with debugging on +mate-screensaver --no-daemon --debug diff --git a/src/gs-auth-helper.c b/src/gs-auth-helper.c new file mode 100644 index 0000000..ea9aefe --- /dev/null +++ b/src/gs-auth-helper.c @@ -0,0 +1,213 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * written by Olaf Kirch + * xscreensaver, Copyright (c) 1993-2004 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +/* The idea here is to be able to run mate-screensaver-dialog without any setuid bits. + * Password verification happens through an external program that you feed + * your password to on stdin. The external command is invoked with a user + * name argument. + * + * The external helper does whatever authentication is necessary. Currently, + * SuSE uses "unix2_chkpwd", which is a variation of "unix_chkpwd" from the + * PAM distribution. + * + * Normally, the password helper should just authenticate the calling user + * (i.e. based on the caller's real uid). This is in order to prevent + * brute-forcing passwords in a shadow environment. A less restrictive + * approach would be to allow verifying other passwords as well, but always + * with a 2 second delay or so. (Not sure what SuSE's "unix2_chkpwd" + * currently does.) + * -- Olaf Kirch , 16-Dec-2003 + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-auth.h" +#include "subprocs.h" + +static gboolean verbose_enabled = FALSE; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static gboolean +ext_run (const char *user, + const char *typed_passwd, + gboolean verbose) +{ + int pfd[2], status; + pid_t pid; + + if (pipe (pfd) < 0) + { + return 0; + } + + if (verbose) + { + g_message ("ext_run (%s, %s)", + PASSWD_HELPER_PROGRAM, user); + } + + block_sigchld (); + + if ((pid = fork ()) < 0) + { + close (pfd [0]); + close (pfd [1]); + return FALSE; + } + + if (pid == 0) + { + close (pfd [1]); + if (pfd [0] != 0) + { + dup2 (pfd [0], 0); + } + + /* Helper is invoked as helper service-name [user] */ + execlp (PASSWD_HELPER_PROGRAM, PASSWD_HELPER_PROGRAM, "mate-screensaver", user, NULL); + if (verbose) + { + g_message ("%s: %s", PASSWD_HELPER_PROGRAM, g_strerror (errno)); + } + + exit (1); + } + + close (pfd [0]); + + /* Write out password to helper process */ + if (!typed_passwd) + { + typed_passwd = ""; + } + write (pfd [1], typed_passwd, strlen (typed_passwd)); + close (pfd [1]); + + while (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + continue; + } + + if (verbose) + { + g_message ("ext_run: waitpid failed: %s\n", + g_strerror (errno)); + } + + unblock_sigchld (); + return FALSE; + } + + unblock_sigchld (); + + if (! WIFEXITED (status) || WEXITSTATUS (status) != 0) + { + return FALSE; + } + + return TRUE; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + gboolean res = FALSE; + char *password; + + password = NULL; + + /* ask for the password for user */ + if (func != NULL) + { + func (GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + "Password: ", + &password, + data); + } + + if (password == NULL) + { + return FALSE; + } + + res = ext_run (username, password, gs_auth_get_verbose ()); + + return res; +} + +gboolean +gs_auth_init (void) +{ + return TRUE; +} + +gboolean +gs_auth_priv_init (void) +{ + /* Make sure the passwd helper exists */ + if (g_access (PASSWD_HELPER_PROGRAM, X_OK) < 0) + { + g_warning ("%s does not exist. " + "password authentication via " + "external helper will not work.", + PASSWD_HELPER_PROGRAM); + return FALSE; + } + + return TRUE; +} diff --git a/src/gs-auth-helper.c.orig b/src/gs-auth-helper.c.orig new file mode 100644 index 0000000..946aef3 --- /dev/null +++ b/src/gs-auth-helper.c.orig @@ -0,0 +1,213 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * written by Olaf Kirch + * xscreensaver, Copyright (c) 1993-2004 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +/* The idea here is to be able to run mate-screensaver-dialog without any setuid bits. + * Password verification happens through an external program that you feed + * your password to on stdin. The external command is invoked with a user + * name argument. + * + * The external helper does whatever authentication is necessary. Currently, + * SuSE uses "unix2_chkpwd", which is a variation of "unix_chkpwd" from the + * PAM distribution. + * + * Normally, the password helper should just authenticate the calling user + * (i.e. based on the caller's real uid). This is in order to prevent + * brute-forcing passwords in a shadow environment. A less restrictive + * approach would be to allow verifying other passwords as well, but always + * with a 2 second delay or so. (Not sure what SuSE's "unix2_chkpwd" + * currently does.) + * -- Olaf Kirch , 16-Dec-2003 + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-auth.h" +#include "subprocs.h" + +static gboolean verbose_enabled = FALSE; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static gboolean +ext_run (const char *user, + const char *typed_passwd, + gboolean verbose) +{ + int pfd[2], status; + pid_t pid; + + if (pipe (pfd) < 0) + { + return 0; + } + + if (verbose) + { + g_message ("ext_run (%s, %s)", + PASSWD_HELPER_PROGRAM, user); + } + + block_sigchld (); + + if ((pid = fork ()) < 0) + { + close (pfd [0]); + close (pfd [1]); + return FALSE; + } + + if (pid == 0) + { + close (pfd [1]); + if (pfd [0] != 0) + { + dup2 (pfd [0], 0); + } + + /* Helper is invoked as helper service-name [user] */ + execlp (PASSWD_HELPER_PROGRAM, PASSWD_HELPER_PROGRAM, "mate-screensaver", user, NULL); + if (verbose) + { + g_message ("%s: %s", PASSWD_HELPER_PROGRAM, g_strerror (errno)); + } + + exit (1); + } + + close (pfd [0]); + + /* Write out password to helper process */ + if (!typed_passwd) + { + typed_passwd = ""; + } + write (pfd [1], typed_passwd, strlen (typed_passwd)); + close (pfd [1]); + + while (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + continue; + } + + if (verbose) + { + g_message ("ext_run: waitpid failed: %s\n", + g_strerror (errno)); + } + + unblock_sigchld (); + return FALSE; + } + + unblock_sigchld (); + + if (! WIFEXITED (status) || WEXITSTATUS (status) != 0) + { + return FALSE; + } + + return TRUE; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + gboolean res = FALSE; + char *password; + + password = NULL; + + /* ask for the password for user */ + if (func != NULL) + { + func (GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + "Password: ", + &password, + data); + } + + if (password == NULL) + { + return FALSE; + } + + res = ext_run (username, password, gs_auth_get_verbose ()); + + return res; +} + +gboolean +gs_auth_init (void) +{ + return TRUE; +} + +gboolean +gs_auth_priv_init (void) +{ + /* Make sure the passwd helper exists */ + if (g_access (PASSWD_HELPER_PROGRAM, X_OK) < 0) + { + g_warning ("%s does not exist. " + "password authentication via " + "external helper will not work.", + PASSWD_HELPER_PROGRAM); + return FALSE; + } + + return TRUE; +} diff --git a/src/gs-auth-pam.c b/src/gs-auth-pam.c new file mode 100644 index 0000000..44c8aca --- /dev/null +++ b/src/gs-auth-pam.c @@ -0,0 +1,843 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * Copyright (C) 2006 Ray Strode + * Copyright (C) 2003 Bill Nottingham + * Copyright (c) 1993-2003 Jamie Zawinski + * + * 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. + * + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "gs-auth.h" + +#include "subprocs.h" + +/* Some time between Red Hat 4.2 and 7.0, the words were transposed + in the various PAM_x_CRED macro names. Yay! +*/ +#ifndef PAM_REFRESH_CRED +# define PAM_REFRESH_CRED PAM_CRED_REFRESH +#endif + +#ifdef HAVE_PAM_FAIL_DELAY +/* We handle delays ourself.*/ +/* Don't set this to 0 (Linux bug workaround.) */ +# define PAM_NO_DELAY(pamh) pam_fail_delay ((pamh), 1) +#else /* !HAVE_PAM_FAIL_DELAY */ +# define PAM_NO_DELAY(pamh) /* */ +#endif /* !HAVE_PAM_FAIL_DELAY */ + + +/* On SunOS 5.6, and on Linux with PAM 0.64, pam_strerror() takes two args. + On some other Linux systems with some other version of PAM (e.g., + whichever Debian release comes with a 2.2.5 kernel) it takes one arg. + I can't tell which is more "recent" or "correct" behavior, so configure + figures out which is in use for us. Shoot me! +*/ +#ifdef PAM_STRERROR_TWO_ARGS +# define PAM_STRERROR(pamh, status) pam_strerror((pamh), (status)) +#else /* !PAM_STRERROR_TWO_ARGS */ +# define PAM_STRERROR(pamh, status) pam_strerror((status)) +#endif /* !PAM_STRERROR_TWO_ARGS */ + +static gboolean verbose_enabled = FALSE; +static pam_handle_t *pam_handle = NULL; +static gboolean did_we_ask_for_password = FALSE; + +struct pam_closure +{ + const char *username; + GSAuthMessageFunc cb_func; + gpointer cb_data; + int signal_fd; + int result; +}; + +typedef struct +{ + struct pam_closure *closure; + GSAuthMessageStyle style; + const char *msg; + char **resp; + gboolean should_interrupt_stack; +} GsAuthMessageHandlerData; + +static GCond *message_handled_condition; +static GMutex *message_handler_mutex; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static GSAuthMessageStyle +pam_style_to_gs_style (int pam_style) +{ + GSAuthMessageStyle style; + + switch (pam_style) + { + case PAM_PROMPT_ECHO_ON: + style = GS_AUTH_MESSAGE_PROMPT_ECHO_ON; + break; + case PAM_PROMPT_ECHO_OFF: + style = GS_AUTH_MESSAGE_PROMPT_ECHO_OFF; + break; + case PAM_ERROR_MSG: + style = GS_AUTH_MESSAGE_ERROR_MSG; + break; + case PAM_TEXT_INFO: + style = GS_AUTH_MESSAGE_TEXT_INFO; + break; + default: + g_assert_not_reached (); + break; + } + + return style; +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + + ret = TRUE; + *response = NULL; + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + if (msg != NULL && g_str_has_prefix (msg, _("Password:"))) + { + did_we_ask_for_password = TRUE; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + break; + default: + g_assert_not_reached (); + } + + return ret; +} + +static gboolean +gs_auth_queued_message_handler (GsAuthMessageHandlerData *data) +{ + gboolean res; + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for lock"); + } + + g_mutex_lock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for response"); + } + + res = data->closure->cb_func (data->style, + data->msg, + data->resp, + data->closure->cb_data); + + data->should_interrupt_stack = res == FALSE; + + g_cond_signal (message_handled_condition); + g_mutex_unlock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Got response"); + } + + return FALSE; +} + +static gboolean +gs_auth_run_message_handler (struct pam_closure *c, + GSAuthMessageStyle style, + const char *msg, + char **resp) +{ + GsAuthMessageHandlerData data; + + data.closure = c; + data.style = style; + data.msg = msg; + data.resp = resp; + data.should_interrupt_stack = TRUE; + + g_mutex_lock (message_handler_mutex); + + /* Queue the callback in the gui (the main) thread + */ + g_idle_add ((GSourceFunc) gs_auth_queued_message_handler, &data); + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for respose to message style %d: '%s'", style, msg); + } + + /* Wait for the response + */ + g_cond_wait (message_handled_condition, + message_handler_mutex); + g_mutex_unlock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Got respose to message style %d: interrupt:%d", style, data.should_interrupt_stack); + } + + return data.should_interrupt_stack == FALSE; +} + +static int +pam_conversation (int nmsgs, + const struct pam_message **msg, + struct pam_response **resp, + void *closure) +{ + int replies = 0; + struct pam_response *reply = NULL; + struct pam_closure *c = (struct pam_closure *) closure; + gboolean res; + int ret; + + reply = (struct pam_response *) calloc (nmsgs, sizeof (*reply)); + + if (reply == NULL) + { + return PAM_CONV_ERR; + } + + res = TRUE; + ret = PAM_SUCCESS; + + for (replies = 0; replies < nmsgs && ret == PAM_SUCCESS; replies++) + { + GSAuthMessageStyle style; + char *utf8_msg; + + style = pam_style_to_gs_style (msg [replies]->msg_style); + + utf8_msg = g_locale_to_utf8 (msg [replies]->msg, + -1, + NULL, + NULL, + NULL); + + /* if we couldn't convert text from locale then + * assume utf-8 and hope for the best */ + if (utf8_msg == NULL) + { + char *p; + char *q; + + utf8_msg = g_strdup (msg [replies]->msg); + + p = utf8_msg; + while (*p != '\0' && !g_utf8_validate ((const char *)p, -1, (const char **)&q)) + { + *q = '?'; + p = q + 1; + } + } + + /* handle message locally first */ + auth_message_handler (style, + utf8_msg, + &reply [replies].resp, + NULL); + + if (c->cb_func != NULL) + { + if (gs_auth_get_verbose ()) + { + g_message ("Handling message style %d: '%s'", style, utf8_msg); + } + + /* blocks until the gui responds + */ + res = gs_auth_run_message_handler (c, + style, + utf8_msg, + &reply [replies].resp); + + if (gs_auth_get_verbose ()) + { + g_message ("Msg handler returned %d", res); + } + + /* If the handler returns FALSE - interrupt the PAM stack */ + if (res) + { + reply [replies].resp_retcode = PAM_SUCCESS; + } + else + { + int i; + for (i = 0; i <= replies; i++) + { + free (reply [i].resp); + } + free (reply); + reply = NULL; + ret = PAM_CONV_ERR; + } + } + + g_free (utf8_msg); + } + + *resp = reply; + + return ret; +} + +static gboolean +close_pam_handle (int status) +{ + + if (pam_handle != NULL) + { + int status2; + + status2 = pam_end (pam_handle, status); + pam_handle = NULL; + + if (gs_auth_get_verbose ()) + { + g_message (" pam_end (...) ==> %d (%s)", + status2, + (status2 == PAM_SUCCESS ? "Success" : "Failure")); + } + } + + if (message_handled_condition != NULL) + { + g_cond_free (message_handled_condition); + message_handled_condition = NULL; + } + + if (message_handler_mutex != NULL) + { + g_mutex_free (message_handler_mutex); + message_handler_mutex = NULL; + } + + return TRUE; +} + +static gboolean +create_pam_handle (const char *username, + const char *display, + struct pam_conv *conv, + int *status_code) +{ + int status; + const char *service = PAM_SERVICE_NAME; + char *disp; + gboolean ret; + + if (pam_handle != NULL) + { + g_warning ("create_pam_handle: Stale pam handle around, cleaning up"); + close_pam_handle (PAM_SUCCESS); + } + + /* init things */ + pam_handle = NULL; + status = -1; + disp = NULL; + ret = TRUE; + + /* Initialize a PAM session for the user */ + if ((status = pam_start (service, username, conv, &pam_handle)) != PAM_SUCCESS) + { + pam_handle = NULL; + g_warning (_("Unable to establish service %s: %s\n"), + service, + PAM_STRERROR (NULL, status)); + + if (status_code != NULL) + { + *status_code = status; + } + + ret = FALSE; + goto out; + } + + if (gs_auth_get_verbose ()) + { + g_message ("pam_start (\"%s\", \"%s\", ...) ==> %d (%s)", + service, + username, + status, + PAM_STRERROR (pam_handle, status)); + } + + disp = g_strdup (display); + if (disp == NULL) + { + disp = g_strdup (":0.0"); + } + + if ((status = pam_set_item (pam_handle, PAM_TTY, disp)) != PAM_SUCCESS) + { + g_warning (_("Can't set PAM_TTY=%s"), display); + + if (status_code != NULL) + { + *status_code = status; + } + + ret = FALSE; + goto out; + } + + ret = TRUE; + message_handled_condition = g_cond_new (); + message_handler_mutex = g_mutex_new (); + +out: + if (status_code != NULL) + { + *status_code = status; + } + + g_free (disp); + + return ret; +} + +static void +set_pam_error (GError **error, + int status) +{ + if (status == PAM_AUTH_ERR || status == PAM_USER_UNKNOWN) + { + char *msg; + + if (did_we_ask_for_password) + { + msg = g_strdup (_("Incorrect password.")); + } + else + { + msg = g_strdup (_("Authentication failed.")); + } + + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_ERROR, + "%s", + msg); + g_free (msg); + } + else if (status == PAM_PERM_DENIED) + { + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_DENIED, + "%s", + _("Not permitted to gain access at this time.")); + } + else if (status == PAM_ACCT_EXPIRED) + { + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_DENIED, + "%s", + _("No longer permitted to access the system.")); + } + +} + +static int +gs_auth_thread_func (int auth_operation_fd) +{ + static const int flags = 0; + int status; + int status2; + struct timespec timeout; + sigset_t set; + const void *p; + + timeout.tv_sec = 0; + timeout.tv_nsec = 1; + + set = block_sigchld (); + + status = pam_authenticate (pam_handle, flags); + + sigtimedwait (&set, NULL, &timeout); + unblock_sigchld (); + + if (gs_auth_get_verbose ()) + { + g_message (" pam_authenticate (...) ==> %d (%s)", + status, + PAM_STRERROR (pam_handle, status)); + } + + if (status != PAM_SUCCESS) + { + goto done; + } + + if ((status = pam_get_item (pam_handle, PAM_USER, &p)) != PAM_SUCCESS) + { + /* is not really an auth problem, but it will + pretty much look as such, it shouldn't really + happen */ + goto done; + } + + /* We don't actually care if the account modules fail or succeed, + * but we need to run them anyway because certain pam modules + * depend on side effects of the account modules getting run. + */ + status2 = pam_acct_mgmt (pam_handle, 0); + + if (gs_auth_get_verbose ()) + { + g_message ("pam_acct_mgmt (...) ==> %d (%s)\n", + status2, + PAM_STRERROR (pam_handle, status2)); + } + + /* FIXME: should we handle these? */ + switch (status2) + { + case PAM_SUCCESS: + break; + case PAM_NEW_AUTHTOK_REQD: + break; + case PAM_AUTHINFO_UNAVAIL: + break; + case PAM_ACCT_EXPIRED: + break; + case PAM_PERM_DENIED: + break; + default : + break; + } + + /* Each time we successfully authenticate, refresh credentials, + for Kerberos/AFS/DCE/etc. If this fails, just ignore that + failure and blunder along; it shouldn't matter. + + Note: this used to be PAM_REFRESH_CRED instead of + PAM_REINITIALIZE_CRED, but Jason Heiss + says that the Linux PAM library ignores that one, and only refreshes + credentials when using PAM_REINITIALIZE_CRED. + */ + status2 = pam_setcred (pam_handle, PAM_REINITIALIZE_CRED); + if (gs_auth_get_verbose ()) + { + g_message (" pam_setcred (...) ==> %d (%s)", + status2, + PAM_STRERROR (pam_handle, status2)); + } + +done: + /* we're done, close the fd and wake up the main + * loop + */ + close (auth_operation_fd); + + return status; +} + +static gboolean +gs_auth_loop_quit (GIOChannel *source, + GIOCondition condition, + gboolean *thread_done) +{ + *thread_done = TRUE; + gtk_main_quit (); + return FALSE; +} + +static gboolean +gs_auth_pam_verify_user (pam_handle_t *handle, + int *status) +{ + GThread *auth_thread; + GIOChannel *channel; + guint watch_id; + int auth_operation_fds[2]; + int auth_status; + gboolean thread_done; + + channel = NULL; + watch_id = 0; + auth_status = PAM_AUTH_ERR; + + /* This pipe gives us a set of fds we can hook into + * the event loop to be notified when our helper thread + * is ready to be reaped. + */ + if (pipe (auth_operation_fds) < 0) + { + goto out; + } + + if (fcntl (auth_operation_fds[0], F_SETFD, FD_CLOEXEC) < 0) + { + close (auth_operation_fds[0]); + close (auth_operation_fds[1]); + goto out; + } + + if (fcntl (auth_operation_fds[1], F_SETFD, FD_CLOEXEC) < 0) + { + close (auth_operation_fds[0]); + close (auth_operation_fds[1]); + goto out; + } + + channel = g_io_channel_unix_new (auth_operation_fds[0]); + + /* we use a recursive main loop to process ui events + * while we wait on a thread to handle the blocking parts + * of pam authentication. + */ + thread_done = FALSE; + watch_id = g_io_add_watch (channel, G_IO_ERR | G_IO_HUP, + (GIOFunc) gs_auth_loop_quit, &thread_done); + + auth_thread = g_thread_create ((GThreadFunc) gs_auth_thread_func, + GINT_TO_POINTER (auth_operation_fds[1]), + TRUE, NULL); + + if (auth_thread == NULL) + { + goto out; + } + + gtk_main (); + + /* if the event loop was quit before the thread is done then we can't + * reap the thread without blocking on it finishing. The + * thread may not ever finish though if the pam module is blocking. + * + * The only time the event loop is going to stop when the thread isn't + * done, however, is if the dialog quits early (from, e.g., "cancel"), + * so we can just exit. An alternative option would be to switch to + * using pthreads directly and calling pthread_cancel. + */ + if (!thread_done) + { + raise (SIGTERM); + } + + auth_status = GPOINTER_TO_INT (g_thread_join (auth_thread)); + +out: + if (watch_id != 0) + { + g_source_remove (watch_id); + } + + if (channel != NULL) + { + g_io_channel_unref (channel); + } + + if (status) + { + *status = auth_status; + } + + return auth_status == PAM_SUCCESS; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + int status = -1; + struct pam_conv conv; + struct pam_closure c; + struct passwd *pwent; + + pwent = getpwnam (username); + if (pwent == NULL) + { + return FALSE; + } + + c.username = username; + c.cb_func = func; + c.cb_data = data; + + conv.conv = &pam_conversation; + conv.appdata_ptr = (void *) &c; + + /* Initialize PAM. */ + create_pam_handle (username, display, &conv, &status); + if (status != PAM_SUCCESS) + { + goto done; + } + + pam_set_item (pam_handle, PAM_USER_PROMPT, _("Username:")); + + PAM_NO_DELAY(pam_handle); + + did_we_ask_for_password = FALSE; + if (! gs_auth_pam_verify_user (pam_handle, &status)) + { + goto done; + } + +done: + if (status != PAM_SUCCESS) + { + set_pam_error (error, status); + } + + close_pam_handle (status); + + return (status == PAM_SUCCESS ? TRUE : FALSE); +} + +gboolean +gs_auth_init (void) +{ + return TRUE; +} + +gboolean +gs_auth_priv_init (void) +{ + /* We have nothing to do at init-time. + However, we might as well do some error checking. + If "/etc/pam.d" exists and is a directory, but "/etc/pam.d/xlock" + does not exist, warn that PAM probably isn't going to work. + + This is a priv-init instead of a non-priv init in case the directory + is unreadable or something (don't know if that actually happens.) + */ + const char dir [] = "/etc/pam.d"; + const char file [] = "/etc/pam.d/" PAM_SERVICE_NAME; + const char file2 [] = "/etc/pam.conf"; + struct stat st; + + if (g_stat (dir, &st) == 0 && st.st_mode & S_IFDIR) + { + if (g_stat (file, &st) != 0) + { + g_warning ("%s does not exist.\n" + "Authentication via PAM is unlikely to work.", + file); + } + } + else if (g_stat (file2, &st) == 0) + { + FILE *f = g_fopen (file2, "r"); + if (f) + { + gboolean ok = FALSE; + char buf[255]; + while (fgets (buf, sizeof(buf), f)) + { + if (strstr (buf, PAM_SERVICE_NAME)) + { + ok = TRUE; + break; + } + } + + fclose (f); + if (!ok) + { + g_warning ("%s does not list the `%s' service.\n" + "Authentication via PAM is unlikely to work.", + file2, PAM_SERVICE_NAME); + } + } + /* else warn about file2 existing but being unreadable? */ + } + else + { + g_warning ("Neither %s nor %s exist.\n" + "Authentication via PAM is unlikely to work.", + file2, file); + } + + /* Return true anyway, just in case. */ + return TRUE; +} diff --git a/src/gs-auth-pam.c.orig b/src/gs-auth-pam.c.orig new file mode 100644 index 0000000..88852d9 --- /dev/null +++ b/src/gs-auth-pam.c.orig @@ -0,0 +1,843 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * Copyright (C) 2006 Ray Strode + * Copyright (C) 2003 Bill Nottingham + * Copyright (c) 1993-2003 Jamie Zawinski + * + * 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. + * + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "gs-auth.h" + +#include "subprocs.h" + +/* Some time between Red Hat 4.2 and 7.0, the words were transposed + in the various PAM_x_CRED macro names. Yay! +*/ +#ifndef PAM_REFRESH_CRED +# define PAM_REFRESH_CRED PAM_CRED_REFRESH +#endif + +#ifdef HAVE_PAM_FAIL_DELAY +/* We handle delays ourself.*/ +/* Don't set this to 0 (Linux bug workaround.) */ +# define PAM_NO_DELAY(pamh) pam_fail_delay ((pamh), 1) +#else /* !HAVE_PAM_FAIL_DELAY */ +# define PAM_NO_DELAY(pamh) /* */ +#endif /* !HAVE_PAM_FAIL_DELAY */ + + +/* On SunOS 5.6, and on Linux with PAM 0.64, pam_strerror() takes two args. + On some other Linux systems with some other version of PAM (e.g., + whichever Debian release comes with a 2.2.5 kernel) it takes one arg. + I can't tell which is more "recent" or "correct" behavior, so configure + figures out which is in use for us. Shoot me! +*/ +#ifdef PAM_STRERROR_TWO_ARGS +# define PAM_STRERROR(pamh, status) pam_strerror((pamh), (status)) +#else /* !PAM_STRERROR_TWO_ARGS */ +# define PAM_STRERROR(pamh, status) pam_strerror((status)) +#endif /* !PAM_STRERROR_TWO_ARGS */ + +static gboolean verbose_enabled = FALSE; +static pam_handle_t *pam_handle = NULL; +static gboolean did_we_ask_for_password = FALSE; + +struct pam_closure +{ + const char *username; + GSAuthMessageFunc cb_func; + gpointer cb_data; + int signal_fd; + int result; +}; + +typedef struct +{ + struct pam_closure *closure; + GSAuthMessageStyle style; + const char *msg; + char **resp; + gboolean should_interrupt_stack; +} GsAuthMessageHandlerData; + +static GCond *message_handled_condition; +static GMutex *message_handler_mutex; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static GSAuthMessageStyle +pam_style_to_gs_style (int pam_style) +{ + GSAuthMessageStyle style; + + switch (pam_style) + { + case PAM_PROMPT_ECHO_ON: + style = GS_AUTH_MESSAGE_PROMPT_ECHO_ON; + break; + case PAM_PROMPT_ECHO_OFF: + style = GS_AUTH_MESSAGE_PROMPT_ECHO_OFF; + break; + case PAM_ERROR_MSG: + style = GS_AUTH_MESSAGE_ERROR_MSG; + break; + case PAM_TEXT_INFO: + style = GS_AUTH_MESSAGE_TEXT_INFO; + break; + default: + g_assert_not_reached (); + break; + } + + return style; +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + + ret = TRUE; + *response = NULL; + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + if (msg != NULL && g_str_has_prefix (msg, _("Password:"))) + { + did_we_ask_for_password = TRUE; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + break; + default: + g_assert_not_reached (); + } + + return ret; +} + +static gboolean +gs_auth_queued_message_handler (GsAuthMessageHandlerData *data) +{ + gboolean res; + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for lock"); + } + + g_mutex_lock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for response"); + } + + res = data->closure->cb_func (data->style, + data->msg, + data->resp, + data->closure->cb_data); + + data->should_interrupt_stack = res == FALSE; + + g_cond_signal (message_handled_condition); + g_mutex_unlock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Got response"); + } + + return FALSE; +} + +static gboolean +gs_auth_run_message_handler (struct pam_closure *c, + GSAuthMessageStyle style, + const char *msg, + char **resp) +{ + GsAuthMessageHandlerData data; + + data.closure = c; + data.style = style; + data.msg = msg; + data.resp = resp; + data.should_interrupt_stack = TRUE; + + g_mutex_lock (message_handler_mutex); + + /* Queue the callback in the gui (the main) thread + */ + g_idle_add ((GSourceFunc) gs_auth_queued_message_handler, &data); + + if (gs_auth_get_verbose ()) + { + g_message ("Waiting for respose to message style %d: '%s'", style, msg); + } + + /* Wait for the response + */ + g_cond_wait (message_handled_condition, + message_handler_mutex); + g_mutex_unlock (message_handler_mutex); + + if (gs_auth_get_verbose ()) + { + g_message ("Got respose to message style %d: interrupt:%d", style, data.should_interrupt_stack); + } + + return data.should_interrupt_stack == FALSE; +} + +static int +pam_conversation (int nmsgs, + const struct pam_message **msg, + struct pam_response **resp, + void *closure) +{ + int replies = 0; + struct pam_response *reply = NULL; + struct pam_closure *c = (struct pam_closure *) closure; + gboolean res; + int ret; + + reply = (struct pam_response *) calloc (nmsgs, sizeof (*reply)); + + if (reply == NULL) + { + return PAM_CONV_ERR; + } + + res = TRUE; + ret = PAM_SUCCESS; + + for (replies = 0; replies < nmsgs && ret == PAM_SUCCESS; replies++) + { + GSAuthMessageStyle style; + char *utf8_msg; + + style = pam_style_to_gs_style (msg [replies]->msg_style); + + utf8_msg = g_locale_to_utf8 (msg [replies]->msg, + -1, + NULL, + NULL, + NULL); + + /* if we couldn't convert text from locale then + * assume utf-8 and hope for the best */ + if (utf8_msg == NULL) + { + char *p; + char *q; + + utf8_msg = g_strdup (msg [replies]->msg); + + p = utf8_msg; + while (*p != '\0' && !g_utf8_validate ((const char *)p, -1, (const char **)&q)) + { + *q = '?'; + p = q + 1; + } + } + + /* handle message locally first */ + auth_message_handler (style, + utf8_msg, + &reply [replies].resp, + NULL); + + if (c->cb_func != NULL) + { + if (gs_auth_get_verbose ()) + { + g_message ("Handling message style %d: '%s'", style, utf8_msg); + } + + /* blocks until the gui responds + */ + res = gs_auth_run_message_handler (c, + style, + utf8_msg, + &reply [replies].resp); + + if (gs_auth_get_verbose ()) + { + g_message ("Msg handler returned %d", res); + } + + /* If the handler returns FALSE - interrupt the PAM stack */ + if (res) + { + reply [replies].resp_retcode = PAM_SUCCESS; + } + else + { + int i; + for (i = 0; i <= replies; i++) + { + free (reply [i].resp); + } + free (reply); + reply = NULL; + ret = PAM_CONV_ERR; + } + } + + g_free (utf8_msg); + } + + *resp = reply; + + return ret; +} + +static gboolean +close_pam_handle (int status) +{ + + if (pam_handle != NULL) + { + int status2; + + status2 = pam_end (pam_handle, status); + pam_handle = NULL; + + if (gs_auth_get_verbose ()) + { + g_message (" pam_end (...) ==> %d (%s)", + status2, + (status2 == PAM_SUCCESS ? "Success" : "Failure")); + } + } + + if (message_handled_condition != NULL) + { + g_cond_free (message_handled_condition); + message_handled_condition = NULL; + } + + if (message_handler_mutex != NULL) + { + g_mutex_free (message_handler_mutex); + message_handler_mutex = NULL; + } + + return TRUE; +} + +static gboolean +create_pam_handle (const char *username, + const char *display, + struct pam_conv *conv, + int *status_code) +{ + int status; + const char *service = PAM_SERVICE_NAME; + char *disp; + gboolean ret; + + if (pam_handle != NULL) + { + g_warning ("create_pam_handle: Stale pam handle around, cleaning up"); + close_pam_handle (PAM_SUCCESS); + } + + /* init things */ + pam_handle = NULL; + status = -1; + disp = NULL; + ret = TRUE; + + /* Initialize a PAM session for the user */ + if ((status = pam_start (service, username, conv, &pam_handle)) != PAM_SUCCESS) + { + pam_handle = NULL; + g_warning (_("Unable to establish service %s: %s\n"), + service, + PAM_STRERROR (NULL, status)); + + if (status_code != NULL) + { + *status_code = status; + } + + ret = FALSE; + goto out; + } + + if (gs_auth_get_verbose ()) + { + g_message ("pam_start (\"%s\", \"%s\", ...) ==> %d (%s)", + service, + username, + status, + PAM_STRERROR (pam_handle, status)); + } + + disp = g_strdup (display); + if (disp == NULL) + { + disp = g_strdup (":0.0"); + } + + if ((status = pam_set_item (pam_handle, PAM_TTY, disp)) != PAM_SUCCESS) + { + g_warning (_("Can't set PAM_TTY=%s"), display); + + if (status_code != NULL) + { + *status_code = status; + } + + ret = FALSE; + goto out; + } + + ret = TRUE; + message_handled_condition = g_cond_new (); + message_handler_mutex = g_mutex_new (); + +out: + if (status_code != NULL) + { + *status_code = status; + } + + g_free (disp); + + return ret; +} + +static void +set_pam_error (GError **error, + int status) +{ + if (status == PAM_AUTH_ERR || status == PAM_USER_UNKNOWN) + { + char *msg; + + if (did_we_ask_for_password) + { + msg = g_strdup (_("Incorrect password.")); + } + else + { + msg = g_strdup (_("Authentication failed.")); + } + + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_ERROR, + "%s", + msg); + g_free (msg); + } + else if (status == PAM_PERM_DENIED) + { + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_DENIED, + "%s", + _("Not permitted to gain access at this time.")); + } + else if (status == PAM_ACCT_EXPIRED) + { + g_set_error (error, + GS_AUTH_ERROR, + GS_AUTH_ERROR_AUTH_DENIED, + "%s", + _("No longer permitted to access the system.")); + } + +} + +static int +gs_auth_thread_func (int auth_operation_fd) +{ + static const int flags = 0; + int status; + int status2; + struct timespec timeout; + sigset_t set; + const void *p; + + timeout.tv_sec = 0; + timeout.tv_nsec = 1; + + set = block_sigchld (); + + status = pam_authenticate (pam_handle, flags); + + sigtimedwait (&set, NULL, &timeout); + unblock_sigchld (); + + if (gs_auth_get_verbose ()) + { + g_message (" pam_authenticate (...) ==> %d (%s)", + status, + PAM_STRERROR (pam_handle, status)); + } + + if (status != PAM_SUCCESS) + { + goto done; + } + + if ((status = pam_get_item (pam_handle, PAM_USER, &p)) != PAM_SUCCESS) + { + /* is not really an auth problem, but it will + pretty much look as such, it shouldn't really + happen */ + goto done; + } + + /* We don't actually care if the account modules fail or succeed, + * but we need to run them anyway because certain pam modules + * depend on side effects of the account modules getting run. + */ + status2 = pam_acct_mgmt (pam_handle, 0); + + if (gs_auth_get_verbose ()) + { + g_message ("pam_acct_mgmt (...) ==> %d (%s)\n", + status2, + PAM_STRERROR (pam_handle, status2)); + } + + /* FIXME: should we handle these? */ + switch (status2) + { + case PAM_SUCCESS: + break; + case PAM_NEW_AUTHTOK_REQD: + break; + case PAM_AUTHINFO_UNAVAIL: + break; + case PAM_ACCT_EXPIRED: + break; + case PAM_PERM_DENIED: + break; + default : + break; + } + + /* Each time we successfully authenticate, refresh credentials, + for Kerberos/AFS/DCE/etc. If this fails, just ignore that + failure and blunder along; it shouldn't matter. + + Note: this used to be PAM_REFRESH_CRED instead of + PAM_REINITIALIZE_CRED, but Jason Heiss + says that the Linux PAM library ignores that one, and only refreshes + credentials when using PAM_REINITIALIZE_CRED. + */ + status2 = pam_setcred (pam_handle, PAM_REINITIALIZE_CRED); + if (gs_auth_get_verbose ()) + { + g_message (" pam_setcred (...) ==> %d (%s)", + status2, + PAM_STRERROR (pam_handle, status2)); + } + +done: + /* we're done, close the fd and wake up the main + * loop + */ + close (auth_operation_fd); + + return status; +} + +static gboolean +gs_auth_loop_quit (GIOChannel *source, + GIOCondition condition, + gboolean *thread_done) +{ + *thread_done = TRUE; + gtk_main_quit (); + return FALSE; +} + +static gboolean +gs_auth_pam_verify_user (pam_handle_t *handle, + int *status) +{ + GThread *auth_thread; + GIOChannel *channel; + guint watch_id; + int auth_operation_fds[2]; + int auth_status; + gboolean thread_done; + + channel = NULL; + watch_id = 0; + auth_status = PAM_AUTH_ERR; + + /* This pipe gives us a set of fds we can hook into + * the event loop to be notified when our helper thread + * is ready to be reaped. + */ + if (pipe (auth_operation_fds) < 0) + { + goto out; + } + + if (fcntl (auth_operation_fds[0], F_SETFD, FD_CLOEXEC) < 0) + { + close (auth_operation_fds[0]); + close (auth_operation_fds[1]); + goto out; + } + + if (fcntl (auth_operation_fds[1], F_SETFD, FD_CLOEXEC) < 0) + { + close (auth_operation_fds[0]); + close (auth_operation_fds[1]); + goto out; + } + + channel = g_io_channel_unix_new (auth_operation_fds[0]); + + /* we use a recursive main loop to process ui events + * while we wait on a thread to handle the blocking parts + * of pam authentication. + */ + thread_done = FALSE; + watch_id = g_io_add_watch (channel, G_IO_ERR | G_IO_HUP, + (GIOFunc) gs_auth_loop_quit, &thread_done); + + auth_thread = g_thread_create ((GThreadFunc) gs_auth_thread_func, + GINT_TO_POINTER (auth_operation_fds[1]), + TRUE, NULL); + + if (auth_thread == NULL) + { + goto out; + } + + gtk_main (); + + /* if the event loop was quit before the thread is done then we can't + * reap the thread without blocking on it finishing. The + * thread may not ever finish though if the pam module is blocking. + * + * The only time the event loop is going to stop when the thread isn't + * done, however, is if the dialog quits early (from, e.g., "cancel"), + * so we can just exit. An alternative option would be to switch to + * using pthreads directly and calling pthread_cancel. + */ + if (!thread_done) + { + raise (SIGTERM); + } + + auth_status = GPOINTER_TO_INT (g_thread_join (auth_thread)); + +out: + if (watch_id != 0) + { + g_source_remove (watch_id); + } + + if (channel != NULL) + { + g_io_channel_unref (channel); + } + + if (status) + { + *status = auth_status; + } + + return auth_status == PAM_SUCCESS; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + int status = -1; + struct pam_conv conv; + struct pam_closure c; + struct passwd *pwent; + + pwent = getpwnam (username); + if (pwent == NULL) + { + return FALSE; + } + + c.username = username; + c.cb_func = func; + c.cb_data = data; + + conv.conv = &pam_conversation; + conv.appdata_ptr = (void *) &c; + + /* Initialize PAM. */ + create_pam_handle (username, display, &conv, &status); + if (status != PAM_SUCCESS) + { + goto done; + } + + pam_set_item (pam_handle, PAM_USER_PROMPT, _("Username:")); + + PAM_NO_DELAY(pam_handle); + + did_we_ask_for_password = FALSE; + if (! gs_auth_pam_verify_user (pam_handle, &status)) + { + goto done; + } + +done: + if (status != PAM_SUCCESS) + { + set_pam_error (error, status); + } + + close_pam_handle (status); + + return (status == PAM_SUCCESS ? TRUE : FALSE); +} + +gboolean +gs_auth_init (void) +{ + return TRUE; +} + +gboolean +gs_auth_priv_init (void) +{ + /* We have nothing to do at init-time. + However, we might as well do some error checking. + If "/etc/pam.d" exists and is a directory, but "/etc/pam.d/xlock" + does not exist, warn that PAM probably isn't going to work. + + This is a priv-init instead of a non-priv init in case the directory + is unreadable or something (don't know if that actually happens.) + */ + const char dir [] = "/etc/pam.d"; + const char file [] = "/etc/pam.d/" PAM_SERVICE_NAME; + const char file2 [] = "/etc/pam.conf"; + struct stat st; + + if (g_stat (dir, &st) == 0 && st.st_mode & S_IFDIR) + { + if (g_stat (file, &st) != 0) + { + g_warning ("%s does not exist.\n" + "Authentication via PAM is unlikely to work.", + file); + } + } + else if (g_stat (file2, &st) == 0) + { + FILE *f = g_fopen (file2, "r"); + if (f) + { + gboolean ok = FALSE; + char buf[255]; + while (fgets (buf, sizeof(buf), f)) + { + if (strstr (buf, PAM_SERVICE_NAME)) + { + ok = TRUE; + break; + } + } + + fclose (f); + if (!ok) + { + g_warning ("%s does not list the `%s' service.\n" + "Authentication via PAM is unlikely to work.", + file2, PAM_SERVICE_NAME); + } + } + /* else warn about file2 existing but being unreadable? */ + } + else + { + g_warning ("Neither %s nor %s exist.\n" + "Authentication via PAM is unlikely to work.", + file2, file); + } + + /* Return true anyway, just in case. */ + return TRUE; +} diff --git a/src/gs-auth-pwent.c b/src/gs-auth-pwent.c new file mode 100644 index 0000000..3fe1b22 --- /dev/null +++ b/src/gs-auth-pwent.c @@ -0,0 +1,291 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (c) 1993-1998 Jamie Zawinski + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#ifdef HAVE_CRYPT_H +# include +#endif + +#include +#include +#include +#include +#include + +#ifdef __bsdi__ +# include +# if _BSDI_VERSION >= 199608 +# define BSD_AUTH +# endif +#endif /* __bsdi__ */ + +#include +#include + +#if defined(HAVE_SHADOW_PASSWD) /* passwds live in /etc/shadow */ + +# include +# define PWTYPE struct spwd * +# define PWPSLOT sp_pwdp +# define GETPW getspnam + +#elif defined(HAVE_ENHANCED_PASSWD) /* passwds live in /tcb/files/auth/ */ +/* M.Matsumoto */ +# include +# include + +# define PWTYPE struct pr_passwd * +# define PWPSLOT ufld.fd_encrypt +# define GETPW getprpwnam + +#elif defined(HAVE_ADJUNCT_PASSWD) + +# include +# include +# include + +# define PWTYPE struct passwd_adjunct * +# define PWPSLOT pwa_passwd +# define GETPW getpwanam + +#elif defined(HAVE_HPUX_PASSWD) + +# include +# include + +# define PWTYPE struct s_passwd * +# define PWPSLOT pw_passwd +# define GETPW getspwnam + +# define HAVE_BIGCRYPT + +#endif + +#include "gs-auth.h" + +static gboolean verbose_enabled = FALSE; + +static char *encrypted_user_passwd = NULL; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static gboolean +passwd_known (const char *pw) +{ + return (pw && + pw[0] != '*' && /* This would be sensible... */ + strlen (pw) > 4); /* ...but this is what Solaris does. */ +} + +static char * +get_encrypted_passwd (const char *user) +{ + char *result = NULL; + +#ifdef PWTYPE + if (user && *user && !result) + { + /* First check the shadow passwords. */ + PWTYPE p = GETPW ((char *) user); + if (p && passwd_known (p->PWPSLOT)) + { + result = g_strdup (p->PWPSLOT); + } + } +#endif /* PWTYPE */ + + if (user && *user && !result) + { + /* Check non-shadow passwords too. */ + struct passwd *p = getpwnam (user); + if (p && passwd_known (p->pw_passwd)) + { + result = g_strdup (p->pw_passwd); + } + } + + /* The manual for passwd(4) on HPUX 10.10 says: + + Password aging is put in effect for a particular user if his + encrypted password in the password file is followed by a comma and + a nonnull string of characters from the above alphabet. This + string defines the "age" needed to implement password aging. + + So this means that passwd->pw_passwd isn't simply a string of cyphertext, + it might have trailing junk. So, if there is a comma in the string, and + that comma is beyond position 13, terminate the string before the comma. + */ + if (result && strlen (result) > 13) + { + char *s = strchr (result + 13, ','); + if (s) + { + *s = 0; + } + } + +#ifndef HAVE_PAM + /* We only issue this warning if not compiled with support for PAM. + If we're using PAM, it's not unheard of that normal pwent passwords + would be unavailable. */ + + if (!result) + { + g_warning ("Couldn't get password of \"%s\"", + (user ? user : "(null)")); + } + +#endif /* !HAVE_PAM */ + + return result; +} + +/* This has to be called before we've changed our effective user ID, + because it might need privileges to get at the encrypted passwords. + Returns false if we weren't able to get any passwords, and therefore, + locking isn't possible. (It will also have written to stderr.) +*/ + +gboolean +gs_auth_priv_init (void) +{ + const char *u; + + u = g_get_user_name (); + + encrypted_user_passwd = get_encrypted_passwd (u); + + if (encrypted_user_passwd != NULL) + { + return TRUE; + } + else + { + return FALSE; + } +} + + +gboolean +gs_auth_init (void) +{ + if (encrypted_user_passwd != NULL) + { + return TRUE; + } + else + { + return FALSE; + } +} + +static gboolean +passwds_match (const char *cleartext, + const char *ciphertext) +{ + char *s = NULL; /* note that on some systems, crypt() may return null */ + + s = (char *) crypt (cleartext, ciphertext); + if (s && !strcmp (s, ciphertext)) + { + return TRUE; + } + +#ifdef HAVE_BIGCRYPT + /* There seems to be no way to tell at runtime if an HP machine is in + "trusted" mode, and thereby, which of crypt() or bigcrypt() we should + be calling to compare passwords. So call them both, and see which + one works. */ + + s = (char *) bigcrypt (cleartext, ciphertext); + if (s && !strcmp (s, ciphertext)) + { + return TRUE; + } + +#endif /* HAVE_BIGCRYPT */ + + return FALSE; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + char *password; + + password = NULL; + + /* ask for the password for user */ + if (func != NULL) + { + func (GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + "Password: ", + &password, + data); + } + + if (password == NULL) + { + return FALSE; + } + + if (encrypted_user_passwd && passwds_match (password, encrypted_user_passwd)) + { + return TRUE; + } + else + { + return FALSE; + } +} diff --git a/src/gs-auth-pwent.c.orig b/src/gs-auth-pwent.c.orig new file mode 100644 index 0000000..21abbee --- /dev/null +++ b/src/gs-auth-pwent.c.orig @@ -0,0 +1,291 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (c) 1993-1998 Jamie Zawinski + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +# include +#endif + +#ifdef HAVE_CRYPT_H +# include +#endif + +#include +#include +#include +#include +#include + +#ifdef __bsdi__ +# include +# if _BSDI_VERSION >= 199608 +# define BSD_AUTH +# endif +#endif /* __bsdi__ */ + +#include +#include + +#if defined(HAVE_SHADOW_PASSWD) /* passwds live in /etc/shadow */ + +# include +# define PWTYPE struct spwd * +# define PWPSLOT sp_pwdp +# define GETPW getspnam + +#elif defined(HAVE_ENHANCED_PASSWD) /* passwds live in /tcb/files/auth/ */ +/* M.Matsumoto */ +# include +# include + +# define PWTYPE struct pr_passwd * +# define PWPSLOT ufld.fd_encrypt +# define GETPW getprpwnam + +#elif defined(HAVE_ADJUNCT_PASSWD) + +# include +# include +# include + +# define PWTYPE struct passwd_adjunct * +# define PWPSLOT pwa_passwd +# define GETPW getpwanam + +#elif defined(HAVE_HPUX_PASSWD) + +# include +# include + +# define PWTYPE struct s_passwd * +# define PWPSLOT pw_passwd +# define GETPW getspwnam + +# define HAVE_BIGCRYPT + +#endif + +#include "gs-auth.h" + +static gboolean verbose_enabled = FALSE; + +static char *encrypted_user_passwd = NULL; + +GQuark +gs_auth_error_quark (void) +{ + static GQuark quark = 0; + if (! quark) + { + quark = g_quark_from_static_string ("gs_auth_error"); + } + + return quark; +} + +void +gs_auth_set_verbose (gboolean enabled) +{ + verbose_enabled = enabled; +} + +gboolean +gs_auth_get_verbose (void) +{ + return verbose_enabled; +} + +static gboolean +passwd_known (const char *pw) +{ + return (pw && + pw[0] != '*' && /* This would be sensible... */ + strlen (pw) > 4); /* ...but this is what Solaris does. */ +} + +static char * +get_encrypted_passwd (const char *user) +{ + char *result = NULL; + +#ifdef PWTYPE + if (user && *user && !result) + { + /* First check the shadow passwords. */ + PWTYPE p = GETPW ((char *) user); + if (p && passwd_known (p->PWPSLOT)) + { + result = g_strdup (p->PWPSLOT); + } + } +#endif /* PWTYPE */ + + if (user && *user && !result) + { + /* Check non-shadow passwords too. */ + struct passwd *p = getpwnam (user); + if (p && passwd_known (p->pw_passwd)) + { + result = g_strdup (p->pw_passwd); + } + } + + /* The manual for passwd(4) on HPUX 10.10 says: + + Password aging is put in effect for a particular user if his + encrypted password in the password file is followed by a comma and + a nonnull string of characters from the above alphabet. This + string defines the "age" needed to implement password aging. + + So this means that passwd->pw_passwd isn't simply a string of cyphertext, + it might have trailing junk. So, if there is a comma in the string, and + that comma is beyond position 13, terminate the string before the comma. + */ + if (result && strlen (result) > 13) + { + char *s = strchr (result + 13, ','); + if (s) + { + *s = 0; + } + } + +#ifndef HAVE_PAM + /* We only issue this warning if not compiled with support for PAM. + If we're using PAM, it's not unheard of that normal pwent passwords + would be unavailable. */ + + if (!result) + { + g_warning ("Couldn't get password of \"%s\"", + (user ? user : "(null)")); + } + +#endif /* !HAVE_PAM */ + + return result; +} + +/* This has to be called before we've changed our effective user ID, + because it might need privileges to get at the encrypted passwords. + Returns false if we weren't able to get any passwords, and therefore, + locking isn't possible. (It will also have written to stderr.) +*/ + +gboolean +gs_auth_priv_init (void) +{ + const char *u; + + u = g_get_user_name (); + + encrypted_user_passwd = get_encrypted_passwd (u); + + if (encrypted_user_passwd != NULL) + { + return TRUE; + } + else + { + return FALSE; + } +} + + +gboolean +gs_auth_init (void) +{ + if (encrypted_user_passwd != NULL) + { + return TRUE; + } + else + { + return FALSE; + } +} + +static gboolean +passwds_match (const char *cleartext, + const char *ciphertext) +{ + char *s = NULL; /* note that on some systems, crypt() may return null */ + + s = (char *) crypt (cleartext, ciphertext); + if (s && !strcmp (s, ciphertext)) + { + return TRUE; + } + +#ifdef HAVE_BIGCRYPT + /* There seems to be no way to tell at runtime if an HP machine is in + "trusted" mode, and thereby, which of crypt() or bigcrypt() we should + be calling to compare passwords. So call them both, and see which + one works. */ + + s = (char *) bigcrypt (cleartext, ciphertext); + if (s && !strcmp (s, ciphertext)) + { + return TRUE; + } + +#endif /* HAVE_BIGCRYPT */ + + return FALSE; +} + +gboolean +gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error) +{ + char *password; + + password = NULL; + + /* ask for the password for user */ + if (func != NULL) + { + func (GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + "Password: ", + &password, + data); + } + + if (password == NULL) + { + return FALSE; + } + + if (encrypted_user_passwd && passwds_match (password, encrypted_user_passwd)) + { + return TRUE; + } + else + { + return FALSE; + } +} diff --git a/src/gs-auth.h b/src/gs-auth.h new file mode 100644 index 0000000..503e92d --- /dev/null +++ b/src/gs-auth.h @@ -0,0 +1,67 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#ifndef __GS_AUTH_H +#define __GS_AUTH_H + +#include + +G_BEGIN_DECLS + +typedef enum +{ + GS_AUTH_MESSAGE_PROMPT_ECHO_ON, + GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + GS_AUTH_MESSAGE_ERROR_MSG, + GS_AUTH_MESSAGE_TEXT_INFO +} GSAuthMessageStyle; + +typedef enum +{ + GS_AUTH_ERROR_GENERAL, + GS_AUTH_ERROR_AUTH_ERROR, + GS_AUTH_ERROR_USER_UNKNOWN, + GS_AUTH_ERROR_AUTH_DENIED +} GSAuthError; + +typedef gboolean (* GSAuthMessageFunc) (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data); + +#define GS_AUTH_ERROR gs_auth_error_quark () + +GQuark gs_auth_error_quark (void); + +void gs_auth_set_verbose (gboolean verbose); +gboolean gs_auth_get_verbose (void); + +gboolean gs_auth_priv_init (void); +gboolean gs_auth_init (void); +gboolean gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error); + +G_END_DECLS + +#endif /* __GS_AUTH_H */ diff --git a/src/gs-auth.h.orig b/src/gs-auth.h.orig new file mode 100644 index 0000000..25e5271 --- /dev/null +++ b/src/gs-auth.h.orig @@ -0,0 +1,65 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#ifndef __GS_AUTH_H +#define __GS_AUTH_H + +#include + +G_BEGIN_DECLS + +typedef enum { + GS_AUTH_MESSAGE_PROMPT_ECHO_ON, + GS_AUTH_MESSAGE_PROMPT_ECHO_OFF, + GS_AUTH_MESSAGE_ERROR_MSG, + GS_AUTH_MESSAGE_TEXT_INFO +} GSAuthMessageStyle; + +typedef enum { + GS_AUTH_ERROR_GENERAL, + GS_AUTH_ERROR_AUTH_ERROR, + GS_AUTH_ERROR_USER_UNKNOWN, + GS_AUTH_ERROR_AUTH_DENIED +} GSAuthError; + +typedef gboolean (* GSAuthMessageFunc) (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data); + +#define GS_AUTH_ERROR gs_auth_error_quark () + +GQuark gs_auth_error_quark (void); + +void gs_auth_set_verbose (gboolean verbose); +gboolean gs_auth_get_verbose (void); + +gboolean gs_auth_priv_init (void); +gboolean gs_auth_init (void); +gboolean gs_auth_verify_user (const char *username, + const char *display, + GSAuthMessageFunc func, + gpointer data, + GError **error); + +G_END_DECLS + +#endif /* __GS_AUTH_H */ diff --git a/src/gs-debug.c b/src/gs-debug.c new file mode 100644 index 0000000..52fbc12 --- /dev/null +++ b/src/gs-debug.c @@ -0,0 +1,163 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-debug.h" + +static gboolean debugging = FALSE; +static FILE *debug_out = NULL; + +/* Based on rhythmbox/lib/rb-debug.c */ +/* Our own funky debugging function, should only be used when something + * is not going wrong, if something *is* wrong use g_warning. + */ +void +gs_debug_real (const char *func, + const char *file, + const int line, + const char *format, ...) +{ + va_list args; + char buffer [1025]; + char *str_time; + time_t the_time; + + if (debugging == FALSE) + return; + + va_start (args, format); + + g_vsnprintf (buffer, 1024, format, args); + + va_end (args); + + time (&the_time); + str_time = g_new0 (char, 255); + strftime (str_time, 254, "%H:%M:%S", localtime (&the_time)); + + fprintf ((debug_out ? debug_out : stderr), + "[%s] %s:%d (%s):\t %s\n", + func, file, line, str_time, buffer); + + if (debug_out) + fflush (debug_out); + + g_free (str_time); +} + +gboolean +gs_debug_enabled (void) +{ + return debugging; +} + +void +gs_debug_init (gboolean debug, + gboolean to_file) +{ + /* return if already initialized */ + if (debugging == TRUE) + { + return; + } + + debugging = debug; + + if (debug && to_file) + { + const char path [50] = "mate_screensaver_debug_XXXXXX"; + int fd; + + fd = g_file_open_tmp (path, NULL, NULL); + + if (fd >= 0) + { + debug_out = fdopen (fd, "a"); + } + } + + gs_debug ("Debugging %s", (debug) ? "enabled" : "disabled"); +} + +void +gs_debug_shutdown (void) +{ + if (! debugging) + return; + + gs_debug ("Shutting down debugging"); + + debugging = FALSE; + + if (debug_out != NULL) + { + fclose (debug_out); + debug_out = NULL; + } +} + +void +_gs_profile_log (const char *func, + const char *note, + const char *format, + ...) +{ + va_list args; + char *str; + char *formatted; + + if (format == NULL) + { + formatted = g_strdup (""); + } + else + { + va_start (args, format); + formatted = g_strdup_vprintf (format, args); + va_end (args); + } + + if (func != NULL) + { + str = g_strdup_printf ("MARK: %s %s: %s %s", g_get_prgname(), func, note ? note : "", formatted); + } + else + { + str = g_strdup_printf ("MARK: %s: %s %s", g_get_prgname(), note ? note : "", formatted); + } + + g_free (formatted); + + g_access (str, F_OK); + g_free (str); +} diff --git a/src/gs-debug.c.orig b/src/gs-debug.c.orig new file mode 100644 index 0000000..ff80c0c --- /dev/null +++ b/src/gs-debug.c.orig @@ -0,0 +1,163 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-debug.h" + +static gboolean debugging = FALSE; +static FILE *debug_out = NULL; + +/* Based on rhythmbox/lib/rb-debug.c */ +/* Our own funky debugging function, should only be used when something + * is not going wrong, if something *is* wrong use g_warning. + */ +void +gs_debug_real (const char *func, + const char *file, + const int line, + const char *format, ...) +{ + va_list args; + char buffer [1025]; + char *str_time; + time_t the_time; + + if (debugging == FALSE) + return; + + va_start (args, format); + + g_vsnprintf (buffer, 1024, format, args); + + va_end (args); + + time (&the_time); + str_time = g_new0 (char, 255); + strftime (str_time, 254, "%H:%M:%S", localtime (&the_time)); + + fprintf ((debug_out ? debug_out : stderr), + "[%s] %s:%d (%s):\t %s\n", + func, file, line, str_time, buffer); + + if (debug_out) + fflush (debug_out); + + g_free (str_time); +} + +gboolean +gs_debug_enabled (void) +{ + return debugging; +} + +void +gs_debug_init (gboolean debug, + gboolean to_file) +{ + /* return if already initialized */ + if (debugging == TRUE) + { + return; + } + + debugging = debug; + + if (debug && to_file) + { + const char path [50] = "mate_screensaver_debug_XXXXXX"; + int fd; + + fd = g_file_open_tmp (path, NULL, NULL); + + if (fd >= 0) + { + debug_out = fdopen (fd, "a"); + } + } + + gs_debug ("Debugging %s", (debug) ? "enabled" : "disabled"); +} + +void +gs_debug_shutdown (void) +{ + if (! debugging) + return; + + gs_debug ("Shutting down debugging"); + + debugging = FALSE; + + if (debug_out != NULL) + { + fclose (debug_out); + debug_out = NULL; + } +} + +void +_gs_profile_log (const char *func, + const char *note, + const char *format, + ...) +{ + va_list args; + char *str; + char *formatted; + + if (format == NULL) + { + formatted = g_strdup (""); + } + else + { + va_start (args, format); + formatted = g_strdup_vprintf (format, args); + va_end (args); + } + + if (func != NULL) + { + str = g_strdup_printf ("MARK: %s %s: %s %s", g_get_prgname(), func, note ? note : "", formatted); + } + else + { + str = g_strdup_printf ("MARK: %s: %s %s", g_get_prgname(), note ? note : "", formatted); + } + + g_free (formatted); + + g_access (str, F_OK); + g_free (str); +} diff --git a/src/gs-debug.h b/src/gs-debug.h new file mode 100644 index 0000000..fdf9fd8 --- /dev/null +++ b/src/gs-debug.h @@ -0,0 +1,71 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_DEBUG_H +#define __GS_DEBUG_H + +#include +#include + +G_BEGIN_DECLS + +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define gs_debug(...) gs_debug_real (__func__, __FILE__, __LINE__, __VA_ARGS__) +#elif defined(__GNUC__) && __GNUC__ >= 3 +#define gs_debug(...) gs_debug_real (__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__) +#else +#define gs_debug(...) +#endif + +void gs_debug_init (gboolean debug, + gboolean to_file); +gboolean gs_debug_enabled (void); +void gs_debug_shutdown (void); +void gs_debug_real (const char *func, + const char *file, + int line, + const char *format, ...); + +#ifdef ENABLE_PROFILING +#ifdef G_HAVE_ISO_VARARGS +#define gs_profile_start(...) _gs_profile_log (G_STRFUNC, "start", __VA_ARGS__) +#define gs_profile_end(...) _gs_profile_log (G_STRFUNC, "end", __VA_ARGS__) +#define gs_profile_msg(...) _gs_profile_log (NULL, NULL, __VA_ARGS__) +#elif defined(G_HAVE_GNUC_VARARGS) +#define gs_profile_start(format...) _gs_profile_log (G_STRFUNC, "start", format) +#define gs_profile_end(format...) _gs_profile_log (G_STRFUNC, "end", format) +#define gs_profile_msg(format...) _gs_profile_log (NULL, NULL, format) +#endif +#else +#define gs_profile_start(...) +#define gs_profile_end(...) +#define gs_profile_msg(...) +#endif + +void _gs_profile_log (const char *func, + const char *note, + const char *format, + ...) G_GNUC_PRINTF (3, 4); + +G_END_DECLS + +#endif /* __GS_DEBUG_H */ diff --git a/src/gs-fade.c b/src/gs-fade.c new file mode 100644 index 0000000..ba04b67 --- /dev/null +++ b/src/gs-fade.c @@ -0,0 +1,987 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2009 William Jon McCann + * Copyright (C) 2009 Red Hat, Inc. + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#include +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#include +#include + +#include "gs-fade.h" +#include "gs-debug.h" + +#define MATE_DESKTOP_USE_UNSTABLE_API + +#include "libmateui/mate-rr.h" + +/* XFree86 4.x+ Gamma fading */ + + +#ifdef HAVE_XF86VMODE_GAMMA + +#include + +#define XF86_MIN_GAMMA 0.1 + +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void gs_fade_class_init (GSFadeClass *klass); +static void gs_fade_init (GSFade *fade); +static void gs_fade_finalize (GObject *object); + +#define GS_FADE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_FADE, GSFadePrivate)) + +struct GSGammaInfo +{ + int size; + unsigned short *r; + unsigned short *g; + unsigned short *b; +}; + +struct GSFadeScreenPrivate +{ + int fade_type; + int num_ramps; + /* one per crtc in randr mode */ + struct GSGammaInfo *info; + /* one per screen in theory */ + MateRRScreen *rrscreen; +#ifdef HAVE_XF86VMODE_GAMMA + /* one per screen also */ + XF86VidModeGamma vmg; +#endif /* HAVE_XF86VMODE_GAMMA */ + gboolean (*fade_setup) (GSFade *fade, + int screen); + gboolean (*fade_set_alpha_gamma) (GSFade *fade, + int screen, + gdouble alpha); + void (*fade_finish) (GSFade *fade, + int screen); +}; + +struct GSFadePrivate +{ + guint enabled : 1; + guint active : 1; + + guint timeout; + + guint step; + guint num_steps; + guint timer_id; + + gdouble alpha_per_iter; + gdouble current_alpha; + + int num_screens; + + struct GSFadeScreenPrivate *screen_priv; +}; + +enum +{ + FADED, + LAST_SIGNAL +}; + +enum +{ + FADE_TYPE_NONE, + FADE_TYPE_GAMMA_NUMBER, + FADE_TYPE_GAMMA_RAMP, + FADE_TYPE_XRANDR, +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSFade, gs_fade, G_TYPE_OBJECT) + +static gpointer fade_object = NULL; + +#ifdef HAVE_XF86VMODE_GAMMA + +/* This is needed because the VidMode extension doesn't work + on remote displays -- but if the remote display has the extension + at all, XF86VidModeQueryExtension returns true, and then + XF86VidModeQueryVersion dies with an X error. +*/ + +static gboolean error_handler_hit = FALSE; + +static int +ignore_all_errors_ehandler (Display *dpy, + XErrorEvent *error) +{ + error_handler_hit = TRUE; + + return 0; +} + +static Bool +safe_XF86VidModeQueryVersion (Display *dpy, + int *majP, + int *minP) +{ + Bool result; + XErrorHandler old_handler; + + XSync (dpy, False); + error_handler_hit = FALSE; + old_handler = XSetErrorHandler (ignore_all_errors_ehandler); + + result = XF86VidModeQueryVersion (dpy, majP, minP); + + XSync (dpy, False); + XSetErrorHandler (old_handler); + XSync (dpy, False); + + return (error_handler_hit + ? False + : result); +} + +static gboolean +xf86_whack_gamma (int screen, + struct GSFadeScreenPrivate *screen_priv, + float ratio) +{ + Bool status; + struct GSGammaInfo *gamma_info; + + gamma_info = screen_priv->info; + + if (!gamma_info) + return FALSE; + + if (ratio < 0) + { + ratio = 0; + } + if (ratio > 1) + { + ratio = 1; + } + + if (gamma_info->size == 0) + { + /* we only have a gamma number, not a ramp. */ + + XF86VidModeGamma g2; + + g2.red = screen_priv->vmg.red * ratio; + g2.green = screen_priv->vmg.green * ratio; + g2.blue = screen_priv->vmg.blue * ratio; + + if (g2.red < XF86_MIN_GAMMA) + { + g2.red = XF86_MIN_GAMMA; + } + if (g2.green < XF86_MIN_GAMMA) + { + g2.green = XF86_MIN_GAMMA; + } + if (g2.blue < XF86_MIN_GAMMA) + { + g2.blue = XF86_MIN_GAMMA; + } + + status = XF86VidModeSetGamma (GDK_DISPLAY (), screen, &g2); + } + else + { + +# ifdef HAVE_XF86VMODE_GAMMA_RAMP + unsigned short *r, *g, *b; + int i; + + r = g_new0 (unsigned short, gamma_info->size); + g = g_new0 (unsigned short, gamma_info->size); + b = g_new0 (unsigned short, gamma_info->size); + + for (i = 0; i < gamma_info->size; i++) + { + r[i] = gamma_info->r[i] * ratio; + g[i] = gamma_info->g[i] * ratio; + b[i] = gamma_info->b[i] * ratio; + } + + status = XF86VidModeSetGammaRamp (GDK_DISPLAY (), screen, gamma_info->size, r, g, b); + + g_free (r); + g_free (g); + g_free (b); + +# else /* !HAVE_XF86VMODE_GAMMA_RAMP */ + abort (); +# endif /* !HAVE_XF86VMODE_GAMMA_RAMP */ + } + + gdk_flush (); + + return status; +} + +#endif /* HAVE_XF86VMODE_GAMMA */ + +/* VidModeExtension version 2.0 or better is needed to do gamma. + 2.0 added gamma values; 2.1 added gamma ramps. +*/ +# define XF86_VIDMODE_GAMMA_MIN_MAJOR 2 +# define XF86_VIDMODE_GAMMA_MIN_MINOR 0 +# define XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR 2 +# define XF86_VIDMODE_GAMMA_RAMP_MIN_MINOR 1 + + +gboolean +gs_fade_get_enabled (GSFade *fade) +{ + g_return_val_if_fail (GS_IS_FADE (fade), FALSE); + + return fade->priv->enabled; +} + +void +gs_fade_set_enabled (GSFade *fade, + gboolean enabled) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + if (fade->priv->enabled != enabled) + { + fade->priv->enabled = enabled; + } +} + +#ifdef HAVE_XF86VMODE_GAMMA +static gboolean +gamma_fade_setup (GSFade *fade, int screen_idx) +{ + gboolean res; + struct GSFadeScreenPrivate *screen_priv; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (screen_priv->info) + return TRUE; + +# ifndef HAVE_XF86VMODE_GAMMA_RAMP + if (FADE_TYPE_GAMMA_RAMP == screen_priv->fade_type) + { + /* server is newer than client! */ + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + } +# endif + +# ifdef HAVE_XF86VMODE_GAMMA_RAMP + + screen_priv->info = g_new0(struct GSGammaInfo, 1); + screen_priv->num_ramps = 1; + + if (FADE_TYPE_GAMMA_RAMP == screen_priv->fade_type) + { + /* have ramps */ + + res = XF86VidModeGetGammaRampSize (GDK_DISPLAY (), screen_idx, &screen_priv->info->size); + if (!res || screen_priv->info->size <= 0) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + + screen_priv->info->r = g_new0 (unsigned short, screen_priv->info->size); + screen_priv->info->g = g_new0 (unsigned short, screen_priv->info->size); + screen_priv->info->b = g_new0 (unsigned short, screen_priv->info->size); + + if (! (screen_priv->info->r && screen_priv->info->g && screen_priv->info->b)) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + + res = XF86VidModeGetGammaRamp (GDK_DISPLAY (), + screen_idx, + screen_priv->info->size, + screen_priv->info->r, + screen_priv->info->g, + screen_priv->info->b); + if (! res) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + gs_debug ("Initialized gamma ramp fade"); + } +# endif /* HAVE_XF86VMODE_GAMMA_RAMP */ + +test_number: + if (FADE_TYPE_GAMMA_NUMBER == screen_priv->fade_type) + { + /* only have gamma parameter, not ramps. */ + + res = XF86VidModeGetGamma (GDK_DISPLAY (), screen_idx, &screen_priv->vmg); + if (! res) + { + screen_priv->fade_type = FADE_TYPE_NONE; + goto test_none; + } + gs_debug ("Initialized gamma fade for screen %d: %f %f %f", + screen_idx, + screen_priv->vmg.red, + screen_priv->vmg.green, + screen_priv->vmg.blue); + } + +test_none: + if (FADE_TYPE_NONE == screen_priv->fade_type) + { + goto FAIL; + } + + return TRUE; +FAIL: + + return FALSE; +} +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void +screen_fade_finish (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; + int i; + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (!screen_priv->info) + return; + + for (i = 0; i < screen_priv->num_ramps; i++) + { + if (screen_priv->info[i].r) + g_free (screen_priv->info[i].r); + if (screen_priv->info[i].g) + g_free (screen_priv->info[i].g); + if (screen_priv->info[i].b) + g_free (screen_priv->info[i].b); + } + + g_free (screen_priv->info); + screen_priv->info = NULL; + screen_priv->num_ramps = 0; +} + +#ifdef HAVE_XF86VMODE_GAMMA +static gboolean +gamma_fade_set_alpha_gamma (GSFade *fade, + int screen_idx, + gdouble alpha) +{ + struct GSFadeScreenPrivate *screen_priv; + gboolean res; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + res = xf86_whack_gamma (screen_idx, screen_priv, alpha); + + return TRUE; +} +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void +check_gamma_extension (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; +#ifdef HAVE_XF86VMODE_GAMMA + int event; + int error; + int major; + int minor; + gboolean res; +#endif /* HAVE_XF86VMODE_GAMMA */ + + screen_priv = &fade->priv->screen_priv[screen_idx]; + +#ifdef HAVE_XF86VMODE_GAMMA + res = XF86VidModeQueryExtension (GDK_DISPLAY (), &event, &error); + if (! res) + goto fade_none; + + res = safe_XF86VidModeQueryVersion (GDK_DISPLAY (), &major, &minor); + if (! res) + goto fade_none; + + if (major < XF86_VIDMODE_GAMMA_MIN_MAJOR || + (major == XF86_VIDMODE_GAMMA_MIN_MAJOR && + minor < XF86_VIDMODE_GAMMA_MIN_MINOR)) + goto fade_none; + + screen_priv->fade_setup = gamma_fade_setup; + screen_priv->fade_finish = screen_fade_finish; + screen_priv->fade_set_alpha_gamma = gamma_fade_set_alpha_gamma; + + if (major < XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR || + (major == XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR && + minor < XF86_VIDMODE_GAMMA_RAMP_MIN_MINOR)) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + return; + } + + /* Copacetic */ + screen_priv->fade_type = FADE_TYPE_GAMMA_RAMP; + return; +fade_none: +#endif + screen_priv->fade_type = FADE_TYPE_NONE; +} + +/* Xrandr support */ + +static gboolean xrandr_fade_setup (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; + MateRRCrtc *crtc; + MateRRCrtc **crtcs; + int crtc_count = 0; + struct GSGammaInfo *info; + gboolean res; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (screen_priv->info) + return TRUE; + + /* refresh the screen info */ + mate_rr_screen_refresh (screen_priv->rrscreen, NULL); + + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + while (*crtcs) + { + crtc_count++; + crtcs++; + }; + + screen_priv->info = g_new0 (struct GSGammaInfo, crtc_count); + screen_priv->num_ramps = crtc_count; + + crtc_count = 0; + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + while (*crtcs) + { + crtc = *crtcs; + + info = &screen_priv->info[crtc_count]; + + /* if no mode ignore crtc */ + if (!mate_rr_crtc_get_current_mode (crtc)) + { + info->size = 0; + info->r = NULL; + info->g = NULL; + info->b = NULL; + } + else + { + res = mate_rr_crtc_get_gamma (crtc, &info->size, + &info->r, &info->g, + &info->b); + if (res == FALSE) + goto fail; + } + + crtcs++; + crtc_count++; + } + return TRUE; +fail: + return FALSE; +} + +static void xrandr_crtc_whack_gamma (MateRRCrtc *crtc, + struct GSGammaInfo *gamma_info, + float ratio) +{ + unsigned short *r, *g, *b; + int i; + + if (gamma_info->size == 0) + return; + + if (ratio < 0) + { + ratio = 0; + } + if (ratio > 1) + { + ratio = 1; + } + + r = g_new0 (unsigned short, gamma_info->size); + g = g_new0 (unsigned short, gamma_info->size); + b = g_new0 (unsigned short, gamma_info->size); + + for (i = 0; i < gamma_info->size; i++) + { + r[i] = gamma_info->r[i] * ratio; + g[i] = gamma_info->g[i] * ratio; + b[i] = gamma_info->b[i] * ratio; + } + + mate_rr_crtc_set_gamma (crtc, gamma_info->size, + r, g, b); + g_free (r); + g_free (g); + g_free (b); +} + +static gboolean xrandr_fade_set_alpha_gamma (GSFade *fade, + int screen_idx, + gdouble alpha) +{ + struct GSFadeScreenPrivate *screen_priv; + struct GSGammaInfo *info; + MateRRCrtc **crtcs; + int i; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (!screen_priv->info) + return FALSE; + + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + i = 0; + + while (*crtcs) + { + info = &screen_priv->info[i]; + xrandr_crtc_whack_gamma (*crtcs, info, alpha); + i++; + crtcs++; + } + return TRUE; +} + +static void +check_randr_extension (GSFade *fade, int screen_idx) +{ + GdkDisplay *display = gdk_display_get_default (); + GdkScreen *screen = gdk_display_get_screen (display, screen_idx); + struct GSFadeScreenPrivate *screen_priv; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + screen_priv->rrscreen = mate_rr_screen_new (screen, + NULL, + NULL, + NULL); + if (!screen_priv->rrscreen) + { + screen_priv->fade_type = FADE_TYPE_NONE; + return; + } + + screen_priv->fade_type = FADE_TYPE_XRANDR; + screen_priv->fade_setup = xrandr_fade_setup; + screen_priv->fade_finish = screen_fade_finish; + screen_priv->fade_set_alpha_gamma = xrandr_fade_set_alpha_gamma; +} + +static gboolean +gs_fade_set_alpha (GSFade *fade, + gdouble alpha) +{ + gboolean ret = FALSE; + int i; + + for (i = 0; i < fade->priv->num_screens; i++) + { + switch (fade->priv->screen_priv[i].fade_type) + { + case FADE_TYPE_GAMMA_RAMP: + case FADE_TYPE_GAMMA_NUMBER: + case FADE_TYPE_XRANDR: + ret = fade->priv->screen_priv[i].fade_set_alpha_gamma (fade, i, alpha); + break; + case FADE_TYPE_NONE: + ret = FALSE; + break; + default: + g_warning ("Unknown fade type"); + ret = FALSE; + break; + } + } + return ret; +} + +static gboolean +gs_fade_out_iter (GSFade *fade) +{ + gboolean ret; + + if (fade->priv->current_alpha < 0.01) + { + return FALSE; + } + + fade->priv->current_alpha -= fade->priv->alpha_per_iter; + + ret = gs_fade_set_alpha (fade, fade->priv->current_alpha); + + return ret; +} + +static gboolean +gs_fade_stop (GSFade *fade) +{ + if (fade->priv->timer_id > 0) + { + g_source_remove (fade->priv->timer_id); + fade->priv->timer_id = 0; + } + + fade->priv->step = 0; + fade->priv->active = FALSE; + + return TRUE; +} + +void +gs_fade_finish (GSFade *fade) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + if (! fade->priv->active) + { + return; + } + + gs_fade_stop (fade); + + g_signal_emit (fade, signals [FADED], 0); + + fade->priv->active = FALSE; +} + +static gboolean +fade_out_timer (GSFade *fade) +{ + gboolean res; + + res = gs_fade_out_iter (fade); + + /* if failed then fade is complete */ + if (! res) + { + gs_fade_finish (fade); + return FALSE; + } + + return TRUE; +} + +gboolean +gs_fade_get_active (GSFade *fade) +{ + g_return_val_if_fail (GS_IS_FADE (fade), FALSE); + + return fade->priv->active; +} + +static void +gs_fade_set_timeout (GSFade *fade, + guint timeout) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + fade->priv->timeout = timeout; +} + +static void +gs_fade_start (GSFade *fade, + guint timeout) +{ + guint steps_per_sec = 30; + guint msecs_per_step; + struct GSFadeScreenPrivate *screen_priv; + gboolean active_fade, res; + int i; + + g_return_if_fail (GS_IS_FADE (fade)); + + for (i = 0; i < fade->priv->num_screens; i++) + { + screen_priv = &fade->priv->screen_priv[i]; + if (screen_priv->fade_type != FADE_TYPE_NONE) + { + res = screen_priv->fade_setup (fade, i); + if (res == FALSE) + return; + } + } + + if (fade->priv->timer_id > 0) + { + gs_fade_stop (fade); + } + + fade->priv->active = TRUE; + + gs_fade_set_timeout (fade, timeout); + + active_fade = FALSE; + for (i = 0; i < fade->priv->num_screens; i++) + { + screen_priv = &fade->priv->screen_priv[i]; + if (screen_priv->fade_type != FADE_TYPE_NONE) + active_fade = TRUE; + } + if (active_fade) + { + guint num_steps; + + num_steps = (fade->priv->timeout / 1000) * steps_per_sec; + msecs_per_step = 1000 / steps_per_sec; + fade->priv->alpha_per_iter = 1.0 / (gdouble)num_steps; + + fade->priv->timer_id = g_timeout_add (msecs_per_step, (GSourceFunc)fade_out_timer, fade); + } + else + { + gs_fade_finish (fade); + } +} + +typedef struct +{ + GSFadeDoneFunc done_cb; + gpointer data; +} FadedCallbackData; + +static void +gs_fade_async_callback (GSFade *fade, + FadedCallbackData *cdata) +{ + g_signal_handlers_disconnect_by_func (fade, + gs_fade_async_callback, + cdata); + + if (cdata->done_cb) + { + cdata->done_cb (fade, cdata->data); + } + + g_free (cdata); +} + +void +gs_fade_async (GSFade *fade, + guint timeout, + GSFadeDoneFunc func, + gpointer data) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + /* if fade is active then pause it */ + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + if (func) + { + FadedCallbackData *cb_data; + + cb_data = g_new0 (FadedCallbackData, 1); + cb_data->done_cb = func; + cb_data->data = data; + + g_signal_connect (fade, "faded", + G_CALLBACK (gs_fade_async_callback), + cb_data); + } + + gs_fade_start (fade, timeout); +} + +static void +gs_fade_sync_callback (GSFade *fade, + int *flag) +{ + *flag = TRUE; + g_signal_handlers_disconnect_by_func (fade, + gs_fade_sync_callback, + flag); +} + +void +gs_fade_sync (GSFade *fade, + guint timeout) +{ + int flag = FALSE; + + g_return_if_fail (GS_IS_FADE (fade)); + + /* if fade is active then pause it */ + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + g_signal_connect (fade, "faded", + G_CALLBACK (gs_fade_sync_callback), + &flag); + + gs_fade_start (fade, timeout); + + while (! flag) + { + gtk_main_iteration (); + } +} + +void +gs_fade_reset (GSFade *fade) +{ + int i; + g_return_if_fail (GS_IS_FADE (fade)); + + gs_debug ("Resetting fade"); + + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + fade->priv->current_alpha = 1.0; + + gs_fade_set_alpha (fade, fade->priv->current_alpha); + + for (i = 0; i < fade->priv->num_screens; i++) + fade->priv->screen_priv[i].fade_finish (fade, i); +} + +static void +gs_fade_class_init (GSFadeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_fade_finalize; + + signals [FADED] = + g_signal_new ("faded", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSFadeClass, faded), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0, G_TYPE_NONE); + + g_type_class_add_private (klass, sizeof (GSFadePrivate)); +} + +static void +gs_fade_init (GSFade *fade) +{ + GdkDisplay *display; + int i; + + fade->priv = GS_FADE_GET_PRIVATE (fade); + + fade->priv->timeout = 1000; + fade->priv->current_alpha = 1.0; + + display = gdk_display_get_default (); + fade->priv->num_screens = gdk_display_get_n_screens (display); + + fade->priv->screen_priv = g_new0 (struct GSFadeScreenPrivate, fade->priv->num_screens); + + for (i = 0; i < fade->priv->num_screens; i++) + { + check_randr_extension (fade, i); + if (!fade->priv->screen_priv[i].fade_type) + check_gamma_extension (fade, i); + gs_debug ("Fade type: %d", fade->priv->screen_priv[i].fade_type); + } +} + +static void +gs_fade_finalize (GObject *object) +{ + GSFade *fade; + int i; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_FADE (object)); + + fade = GS_FADE (object); + + g_return_if_fail (fade->priv != NULL); + + for (i = 0; i < fade->priv->num_screens; i++) + fade->priv->screen_priv[i].fade_finish(fade, i); + + if (fade->priv->screen_priv) + { + for (i = 0; i < fade->priv->num_screens; i++) + { + if (!fade->priv->screen_priv[i].rrscreen) + continue; + mate_rr_screen_destroy (fade->priv->screen_priv[i].rrscreen); + } + + g_free (fade->priv->screen_priv); + fade->priv->screen_priv = NULL; + } + + G_OBJECT_CLASS (gs_fade_parent_class)->finalize (object); +} + +GSFade * +gs_fade_new (void) +{ + if (fade_object) + { + g_object_ref (fade_object); + } + else + { + fade_object = g_object_new (GS_TYPE_FADE, NULL); + g_object_add_weak_pointer (fade_object, + (gpointer *) &fade_object); + } + + return GS_FADE (fade_object); +} diff --git a/src/gs-fade.c.orig b/src/gs-fade.c.orig new file mode 100644 index 0000000..3b46004 --- /dev/null +++ b/src/gs-fade.c.orig @@ -0,0 +1,987 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2009 William Jon McCann + * Copyright (C) 2009 Red Hat, Inc. + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#include +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#include +#include + +#include "gs-fade.h" +#include "gs-debug.h" + +#define MATE_DESKTOP_USE_UNSTABLE_API + +#include "libmateui/mate-rr.h" + +/* XFree86 4.x+ Gamma fading */ + + +#ifdef HAVE_XF86VMODE_GAMMA + +#include + +#define XF86_MIN_GAMMA 0.1 + +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void gs_fade_class_init (GSFadeClass *klass); +static void gs_fade_init (GSFade *fade); +static void gs_fade_finalize (GObject *object); + +#define GS_FADE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_FADE, GSFadePrivate)) + +struct GSGammaInfo +{ + int size; + unsigned short *r; + unsigned short *g; + unsigned short *b; +}; + +struct GSFadeScreenPrivate +{ + int fade_type; + int num_ramps; + /* one per crtc in randr mode */ + struct GSGammaInfo *info; + /* one per screen in theory */ + MateRRScreen *rrscreen; +#ifdef HAVE_XF86VMODE_GAMMA + /* one per screen also */ + XF86VidModeGamma vmg; +#endif /* HAVE_XF86VMODE_GAMMA */ + gboolean (*fade_setup) (GSFade *fade, + int screen); + gboolean (*fade_set_alpha_gamma) (GSFade *fade, + int screen, + gdouble alpha); + void (*fade_finish) (GSFade *fade, + int screen); +}; + +struct GSFadePrivate +{ + guint enabled : 1; + guint active : 1; + + guint timeout; + + guint step; + guint num_steps; + guint timer_id; + + gdouble alpha_per_iter; + gdouble current_alpha; + + int num_screens; + + struct GSFadeScreenPrivate *screen_priv; +}; + +enum +{ + FADED, + LAST_SIGNAL +}; + +enum +{ + FADE_TYPE_NONE, + FADE_TYPE_GAMMA_NUMBER, + FADE_TYPE_GAMMA_RAMP, + FADE_TYPE_XRANDR, +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSFade, gs_fade, G_TYPE_OBJECT) + +static gpointer fade_object = NULL; + +#ifdef HAVE_XF86VMODE_GAMMA + +/* This is needed because the VidMode extension doesn't work + on remote displays -- but if the remote display has the extension + at all, XF86VidModeQueryExtension returns true, and then + XF86VidModeQueryVersion dies with an X error. +*/ + +static gboolean error_handler_hit = FALSE; + +static int +ignore_all_errors_ehandler (Display *dpy, + XErrorEvent *error) +{ + error_handler_hit = TRUE; + + return 0; +} + +static Bool +safe_XF86VidModeQueryVersion (Display *dpy, + int *majP, + int *minP) +{ + Bool result; + XErrorHandler old_handler; + + XSync (dpy, False); + error_handler_hit = FALSE; + old_handler = XSetErrorHandler (ignore_all_errors_ehandler); + + result = XF86VidModeQueryVersion (dpy, majP, minP); + + XSync (dpy, False); + XSetErrorHandler (old_handler); + XSync (dpy, False); + + return (error_handler_hit + ? False + : result); +} + +static gboolean +xf86_whack_gamma (int screen, + struct GSFadeScreenPrivate *screen_priv, + float ratio) +{ + Bool status; + struct GSGammaInfo *gamma_info; + + gamma_info = screen_priv->info; + + if (!gamma_info) + return FALSE; + + if (ratio < 0) + { + ratio = 0; + } + if (ratio > 1) + { + ratio = 1; + } + + if (gamma_info->size == 0) + { + /* we only have a gamma number, not a ramp. */ + + XF86VidModeGamma g2; + + g2.red = screen_priv->vmg.red * ratio; + g2.green = screen_priv->vmg.green * ratio; + g2.blue = screen_priv->vmg.blue * ratio; + + if (g2.red < XF86_MIN_GAMMA) + { + g2.red = XF86_MIN_GAMMA; + } + if (g2.green < XF86_MIN_GAMMA) + { + g2.green = XF86_MIN_GAMMA; + } + if (g2.blue < XF86_MIN_GAMMA) + { + g2.blue = XF86_MIN_GAMMA; + } + + status = XF86VidModeSetGamma (GDK_DISPLAY (), screen, &g2); + } + else + { + +# ifdef HAVE_XF86VMODE_GAMMA_RAMP + unsigned short *r, *g, *b; + int i; + + r = g_new0 (unsigned short, gamma_info->size); + g = g_new0 (unsigned short, gamma_info->size); + b = g_new0 (unsigned short, gamma_info->size); + + for (i = 0; i < gamma_info->size; i++) + { + r[i] = gamma_info->r[i] * ratio; + g[i] = gamma_info->g[i] * ratio; + b[i] = gamma_info->b[i] * ratio; + } + + status = XF86VidModeSetGammaRamp (GDK_DISPLAY (), screen, gamma_info->size, r, g, b); + + g_free (r); + g_free (g); + g_free (b); + +# else /* !HAVE_XF86VMODE_GAMMA_RAMP */ + abort (); +# endif /* !HAVE_XF86VMODE_GAMMA_RAMP */ + } + + gdk_flush (); + + return status; +} + +#endif /* HAVE_XF86VMODE_GAMMA */ + +/* VidModeExtension version 2.0 or better is needed to do gamma. + 2.0 added gamma values; 2.1 added gamma ramps. +*/ +# define XF86_VIDMODE_GAMMA_MIN_MAJOR 2 +# define XF86_VIDMODE_GAMMA_MIN_MINOR 0 +# define XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR 2 +# define XF86_VIDMODE_GAMMA_RAMP_MIN_MINOR 1 + + +gboolean +gs_fade_get_enabled (GSFade *fade) +{ + g_return_val_if_fail (GS_IS_FADE (fade), FALSE); + + return fade->priv->enabled; +} + +void +gs_fade_set_enabled (GSFade *fade, + gboolean enabled) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + if (fade->priv->enabled != enabled) + { + fade->priv->enabled = enabled; + } +} + +#ifdef HAVE_XF86VMODE_GAMMA +static gboolean +gamma_fade_setup (GSFade *fade, int screen_idx) +{ + gboolean res; + struct GSFadeScreenPrivate *screen_priv; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (screen_priv->info) + return TRUE; + +# ifndef HAVE_XF86VMODE_GAMMA_RAMP + if (FADE_TYPE_GAMMA_RAMP == screen_priv->fade_type) + { + /* server is newer than client! */ + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + } +# endif + +# ifdef HAVE_XF86VMODE_GAMMA_RAMP + + screen_priv->info = g_new0(struct GSGammaInfo, 1); + screen_priv->num_ramps = 1; + + if (FADE_TYPE_GAMMA_RAMP == screen_priv->fade_type) + { + /* have ramps */ + + res = XF86VidModeGetGammaRampSize (GDK_DISPLAY (), screen_idx, &screen_priv->info->size); + if (!res || screen_priv->info->size <= 0) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + + screen_priv->info->r = g_new0 (unsigned short, screen_priv->info->size); + screen_priv->info->g = g_new0 (unsigned short, screen_priv->info->size); + screen_priv->info->b = g_new0 (unsigned short, screen_priv->info->size); + + if (! (screen_priv->info->r && screen_priv->info->g && screen_priv->info->b)) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + + res = XF86VidModeGetGammaRamp (GDK_DISPLAY (), + screen_idx, + screen_priv->info->size, + screen_priv->info->r, + screen_priv->info->g, + screen_priv->info->b); + if (! res) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + goto test_number; + } + gs_debug ("Initialized gamma ramp fade"); + } +# endif /* HAVE_XF86VMODE_GAMMA_RAMP */ + +test_number: + if (FADE_TYPE_GAMMA_NUMBER == screen_priv->fade_type) + { + /* only have gamma parameter, not ramps. */ + + res = XF86VidModeGetGamma (GDK_DISPLAY (), screen_idx, &screen_priv->vmg); + if (! res) + { + screen_priv->fade_type = FADE_TYPE_NONE; + goto test_none; + } + gs_debug ("Initialized gamma fade for screen %d: %f %f %f", + screen_idx, + screen_priv->vmg.red, + screen_priv->vmg.green, + screen_priv->vmg.blue); + } + +test_none: + if (FADE_TYPE_NONE == screen_priv->fade_type) + { + goto FAIL; + } + + return TRUE; +FAIL: + + return FALSE; +} +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void +screen_fade_finish (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; + int i; + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (!screen_priv->info) + return; + + for (i = 0; i < screen_priv->num_ramps; i++) + { + if (screen_priv->info[i].r) + g_free (screen_priv->info[i].r); + if (screen_priv->info[i].g) + g_free (screen_priv->info[i].g); + if (screen_priv->info[i].b) + g_free (screen_priv->info[i].b); + } + + g_free (screen_priv->info); + screen_priv->info = NULL; + screen_priv->num_ramps = 0; +} + +#ifdef HAVE_XF86VMODE_GAMMA +static gboolean +gamma_fade_set_alpha_gamma (GSFade *fade, + int screen_idx, + gdouble alpha) +{ + struct GSFadeScreenPrivate *screen_priv; + gboolean res; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + res = xf86_whack_gamma (screen_idx, screen_priv, alpha); + + return TRUE; +} +#endif /* HAVE_XF86VMODE_GAMMA */ + +static void +check_gamma_extension (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; +#ifdef HAVE_XF86VMODE_GAMMA + int event; + int error; + int major; + int minor; + gboolean res; +#endif /* HAVE_XF86VMODE_GAMMA */ + + screen_priv = &fade->priv->screen_priv[screen_idx]; + +#ifdef HAVE_XF86VMODE_GAMMA + res = XF86VidModeQueryExtension (GDK_DISPLAY (), &event, &error); + if (! res) + goto fade_none; + + res = safe_XF86VidModeQueryVersion (GDK_DISPLAY (), &major, &minor); + if (! res) + goto fade_none; + + if (major < XF86_VIDMODE_GAMMA_MIN_MAJOR || + (major == XF86_VIDMODE_GAMMA_MIN_MAJOR && + minor < XF86_VIDMODE_GAMMA_MIN_MINOR)) + goto fade_none; + + screen_priv->fade_setup = gamma_fade_setup; + screen_priv->fade_finish = screen_fade_finish; + screen_priv->fade_set_alpha_gamma = gamma_fade_set_alpha_gamma; + + if (major < XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR || + (major == XF86_VIDMODE_GAMMA_RAMP_MIN_MAJOR && + minor < XF86_VIDMODE_GAMMA_RAMP_MIN_MINOR)) + { + screen_priv->fade_type = FADE_TYPE_GAMMA_NUMBER; + return; + } + + /* Copacetic */ + screen_priv->fade_type = FADE_TYPE_GAMMA_RAMP; + return; +fade_none: +#endif + screen_priv->fade_type = FADE_TYPE_NONE; +} + +/* Xrandr support */ + +static gboolean xrandr_fade_setup (GSFade *fade, int screen_idx) +{ + struct GSFadeScreenPrivate *screen_priv; + MateRRCrtc *crtc; + MateRRCrtc **crtcs; + int crtc_count = 0; + struct GSGammaInfo *info; + gboolean res; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (screen_priv->info) + return TRUE; + + /* refresh the screen info */ + mate_rr_screen_refresh (screen_priv->rrscreen, NULL); + + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + while (*crtcs) + { + crtc_count++; + crtcs++; + }; + + screen_priv->info = g_new0 (struct GSGammaInfo, crtc_count); + screen_priv->num_ramps = crtc_count; + + crtc_count = 0; + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + while (*crtcs) + { + crtc = *crtcs; + + info = &screen_priv->info[crtc_count]; + + /* if no mode ignore crtc */ + if (!mate_rr_crtc_get_current_mode (crtc)) + { + info->size = 0; + info->r = NULL; + info->g = NULL; + info->b = NULL; + } + else + { + res = mate_rr_crtc_get_gamma (crtc, &info->size, + &info->r, &info->g, + &info->b); + if (res == FALSE) + goto fail; + } + + crtcs++; + crtc_count++; + } + return TRUE; +fail: + return FALSE; +} + +static void xrandr_crtc_whack_gamma (MateRRCrtc *crtc, + struct GSGammaInfo *gamma_info, + float ratio) +{ + unsigned short *r, *g, *b; + int i; + + if (gamma_info->size == 0) + return; + + if (ratio < 0) + { + ratio = 0; + } + if (ratio > 1) + { + ratio = 1; + } + + r = g_new0 (unsigned short, gamma_info->size); + g = g_new0 (unsigned short, gamma_info->size); + b = g_new0 (unsigned short, gamma_info->size); + + for (i = 0; i < gamma_info->size; i++) + { + r[i] = gamma_info->r[i] * ratio; + g[i] = gamma_info->g[i] * ratio; + b[i] = gamma_info->b[i] * ratio; + } + + mate_rr_crtc_set_gamma (crtc, gamma_info->size, + r, g, b); + g_free (r); + g_free (g); + g_free (b); +} + +static gboolean xrandr_fade_set_alpha_gamma (GSFade *fade, + int screen_idx, + gdouble alpha) +{ + struct GSFadeScreenPrivate *screen_priv; + struct GSGammaInfo *info; + MateRRCrtc **crtcs; + int i; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + if (!screen_priv->info) + return FALSE; + + crtcs = mate_rr_screen_list_crtcs (screen_priv->rrscreen); + i = 0; + + while (*crtcs) + { + info = &screen_priv->info[i]; + xrandr_crtc_whack_gamma (*crtcs, info, alpha); + i++; + crtcs++; + } + return TRUE; +} + +static void +check_randr_extension (GSFade *fade, int screen_idx) +{ + GdkDisplay *display = gdk_display_get_default (); + GdkScreen *screen = gdk_display_get_screen (display, screen_idx); + struct GSFadeScreenPrivate *screen_priv; + + screen_priv = &fade->priv->screen_priv[screen_idx]; + + screen_priv->rrscreen = mate_rr_screen_new (screen, + NULL, + NULL, + NULL); + if (!screen_priv->rrscreen) + { + screen_priv->fade_type = FADE_TYPE_NONE; + return; + } + + screen_priv->fade_type = FADE_TYPE_XRANDR; + screen_priv->fade_setup = xrandr_fade_setup; + screen_priv->fade_finish = screen_fade_finish; + screen_priv->fade_set_alpha_gamma = xrandr_fade_set_alpha_gamma; +} + +static gboolean +gs_fade_set_alpha (GSFade *fade, + gdouble alpha) +{ + gboolean ret = FALSE; + int i; + + for (i = 0; i < fade->priv->num_screens; i++) + { + switch (fade->priv->screen_priv[i].fade_type) + { + case FADE_TYPE_GAMMA_RAMP: + case FADE_TYPE_GAMMA_NUMBER: + case FADE_TYPE_XRANDR: + ret = fade->priv->screen_priv[i].fade_set_alpha_gamma (fade, i, alpha); + break; + case FADE_TYPE_NONE: + ret = FALSE; + break; + default: + g_warning ("Unknown fade type"); + ret = FALSE; + break; + } + } + return ret; +} + +static gboolean +gs_fade_out_iter (GSFade *fade) +{ + gboolean ret; + + if (fade->priv->current_alpha < 0.01) + { + return FALSE; + } + + fade->priv->current_alpha -= fade->priv->alpha_per_iter; + + ret = gs_fade_set_alpha (fade, fade->priv->current_alpha); + + return ret; +} + +static gboolean +gs_fade_stop (GSFade *fade) +{ + if (fade->priv->timer_id > 0) + { + g_source_remove (fade->priv->timer_id); + fade->priv->timer_id = 0; + } + + fade->priv->step = 0; + fade->priv->active = FALSE; + + return TRUE; +} + +void +gs_fade_finish (GSFade *fade) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + if (! fade->priv->active) + { + return; + } + + gs_fade_stop (fade); + + g_signal_emit (fade, signals [FADED], 0); + + fade->priv->active = FALSE; +} + +static gboolean +fade_out_timer (GSFade *fade) +{ + gboolean res; + + res = gs_fade_out_iter (fade); + + /* if failed then fade is complete */ + if (! res) + { + gs_fade_finish (fade); + return FALSE; + } + + return TRUE; +} + +gboolean +gs_fade_get_active (GSFade *fade) +{ + g_return_val_if_fail (GS_IS_FADE (fade), FALSE); + + return fade->priv->active; +} + +static void +gs_fade_set_timeout (GSFade *fade, + guint timeout) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + fade->priv->timeout = timeout; +} + +static void +gs_fade_start (GSFade *fade, + guint timeout) +{ + guint steps_per_sec = 30; + guint msecs_per_step; + struct GSFadeScreenPrivate *screen_priv; + gboolean active_fade, res; + int i; + + g_return_if_fail (GS_IS_FADE (fade)); + + for (i = 0; i < fade->priv->num_screens; i++) + { + screen_priv = &fade->priv->screen_priv[i]; + if (screen_priv->fade_type != FADE_TYPE_NONE) + { + res = screen_priv->fade_setup (fade, i); + if (res == FALSE) + return; + } + } + + if (fade->priv->timer_id > 0) + { + gs_fade_stop (fade); + } + + fade->priv->active = TRUE; + + gs_fade_set_timeout (fade, timeout); + + active_fade = FALSE; + for (i = 0; i < fade->priv->num_screens; i++) + { + screen_priv = &fade->priv->screen_priv[i]; + if (screen_priv->fade_type != FADE_TYPE_NONE) + active_fade = TRUE; + } + if (active_fade) + { + guint num_steps; + + num_steps = (fade->priv->timeout / 1000) * steps_per_sec; + msecs_per_step = 1000 / steps_per_sec; + fade->priv->alpha_per_iter = 1.0 / (gdouble)num_steps; + + fade->priv->timer_id = g_timeout_add (msecs_per_step, (GSourceFunc)fade_out_timer, fade); + } + else + { + gs_fade_finish (fade); + } +} + +typedef struct +{ + GSFadeDoneFunc done_cb; + gpointer data; +} FadedCallbackData; + +static void +gs_fade_async_callback (GSFade *fade, + FadedCallbackData *cdata) +{ + g_signal_handlers_disconnect_by_func (fade, + gs_fade_async_callback, + cdata); + + if (cdata->done_cb) + { + cdata->done_cb (fade, cdata->data); + } + + g_free (cdata); +} + +void +gs_fade_async (GSFade *fade, + guint timeout, + GSFadeDoneFunc func, + gpointer data) +{ + g_return_if_fail (GS_IS_FADE (fade)); + + /* if fade is active then pause it */ + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + if (func) + { + FadedCallbackData *cb_data; + + cb_data = g_new0 (FadedCallbackData, 1); + cb_data->done_cb = func; + cb_data->data = data; + + g_signal_connect (fade, "faded", + G_CALLBACK (gs_fade_async_callback), + cb_data); + } + + gs_fade_start (fade, timeout); +} + +static void +gs_fade_sync_callback (GSFade *fade, + int *flag) +{ + *flag = TRUE; + g_signal_handlers_disconnect_by_func (fade, + gs_fade_sync_callback, + flag); +} + +void +gs_fade_sync (GSFade *fade, + guint timeout) +{ + int flag = FALSE; + + g_return_if_fail (GS_IS_FADE (fade)); + + /* if fade is active then pause it */ + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + g_signal_connect (fade, "faded", + G_CALLBACK (gs_fade_sync_callback), + &flag); + + gs_fade_start (fade, timeout); + + while (! flag) + { + gtk_main_iteration (); + } +} + +void +gs_fade_reset (GSFade *fade) +{ + int i; + g_return_if_fail (GS_IS_FADE (fade)); + + gs_debug ("Resetting fade"); + + if (fade->priv->active) + { + gs_fade_stop (fade); + } + + fade->priv->current_alpha = 1.0; + + gs_fade_set_alpha (fade, fade->priv->current_alpha); + + for (i = 0; i < fade->priv->num_screens; i++) + fade->priv->screen_priv[i].fade_finish (fade, i); +} + +static void +gs_fade_class_init (GSFadeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_fade_finalize; + + signals [FADED] = + g_signal_new ("faded", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSFadeClass, faded), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0, G_TYPE_NONE); + + g_type_class_add_private (klass, sizeof (GSFadePrivate)); +} + +static void +gs_fade_init (GSFade *fade) +{ + GdkDisplay *display; + int i; + + fade->priv = GS_FADE_GET_PRIVATE (fade); + + fade->priv->timeout = 1000; + fade->priv->current_alpha = 1.0; + + display = gdk_display_get_default (); + fade->priv->num_screens = gdk_display_get_n_screens (display); + + fade->priv->screen_priv = g_new0 (struct GSFadeScreenPrivate, fade->priv->num_screens); + + for (i = 0; i < fade->priv->num_screens; i++) + { + check_randr_extension (fade, i); + if (!fade->priv->screen_priv[i].fade_type) + check_gamma_extension (fade, i); + gs_debug ("Fade type: %d", fade->priv->screen_priv[i].fade_type); + } +} + +static void +gs_fade_finalize (GObject *object) +{ + GSFade *fade; + int i; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_FADE (object)); + + fade = GS_FADE (object); + + g_return_if_fail (fade->priv != NULL); + + for (i = 0; i < fade->priv->num_screens; i++) + fade->priv->screen_priv[i].fade_finish(fade, i); + + if (fade->priv->screen_priv) + { + for (i = 0; i < fade->priv->num_screens; i++) + { + if (!fade->priv->screen_priv[i].rrscreen) + continue; + mate_rr_screen_destroy (fade->priv->screen_priv[i].rrscreen); + } + + g_free (fade->priv->screen_priv); + fade->priv->screen_priv = NULL; + } + + G_OBJECT_CLASS (gs_fade_parent_class)->finalize (object); +} + +GSFade * +gs_fade_new (void) +{ + if (fade_object) + { + g_object_ref (fade_object); + } + else + { + fade_object = g_object_new (GS_TYPE_FADE, NULL); + g_object_add_weak_pointer (fade_object, + (gpointer *) &fade_object); + } + + return GS_FADE (fade_object); +} diff --git a/src/gs-fade.h b/src/gs-fade.h new file mode 100644 index 0000000..65f3e7f --- /dev/null +++ b/src/gs-fade.h @@ -0,0 +1,77 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_FADE_H +#define __GS_FADE_H + +G_BEGIN_DECLS + +#define GS_TYPE_FADE (gs_fade_get_type ()) +#define GS_FADE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_FADE, GSFade)) +#define GS_FADE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_FADE, GSFadeClass)) +#define GS_IS_FADE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_FADE)) +#define GS_IS_FADE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_FADE)) +#define GS_FADE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_FADE, GSFadeClass)) + + +typedef struct GSFadePrivate GSFadePrivate; + +typedef struct +{ + GObject parent; + GSFadePrivate *priv; +} GSFade; + +typedef struct +{ + GObjectClass parent_class; + + void (* faded) (GSFade *fade); +} GSFadeClass; + +typedef void (* GSFadeDoneFunc) (GSFade *fade, + gpointer data); + + +GType gs_fade_get_type (void); + +GSFade * gs_fade_new (void); + +void gs_fade_async (GSFade *fade, + guint timeout, + GSFadeDoneFunc done_cb, + gpointer data); +void gs_fade_sync (GSFade *fade, + guint timeout); + +void gs_fade_finish (GSFade *fade); +void gs_fade_reset (GSFade *fade); + +gboolean gs_fade_get_active (GSFade *fade); + +gboolean gs_fade_get_enabled (GSFade *fade); +void gs_fade_set_enabled (GSFade *fade, + gboolean enabled); + +G_END_DECLS + +#endif /* __GS_FADE_H */ diff --git a/src/gs-fade.h.orig b/src/gs-fade.h.orig new file mode 100644 index 0000000..bfa7c2a --- /dev/null +++ b/src/gs-fade.h.orig @@ -0,0 +1,77 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_FADE_H +#define __GS_FADE_H + +G_BEGIN_DECLS + +#define GS_TYPE_FADE (gs_fade_get_type ()) +#define GS_FADE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_FADE, GSFade)) +#define GS_FADE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_FADE, GSFadeClass)) +#define GS_IS_FADE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_FADE)) +#define GS_IS_FADE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_FADE)) +#define GS_FADE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_FADE, GSFadeClass)) + + +typedef struct GSFadePrivate GSFadePrivate; + +typedef struct +{ + GObject parent; + GSFadePrivate *priv; +} GSFade; + +typedef struct +{ + GObjectClass parent_class; + + void (* faded) (GSFade *fade); +} GSFadeClass; + +typedef void (* GSFadeDoneFunc) (GSFade *fade, + gpointer data); + + +GType gs_fade_get_type (void); + +GSFade * gs_fade_new (void); + +void gs_fade_async (GSFade *fade, + guint timeout, + GSFadeDoneFunc done_cb, + gpointer data); +void gs_fade_sync (GSFade *fade, + guint timeout); + +void gs_fade_finish (GSFade *fade); +void gs_fade_reset (GSFade *fade); + +gboolean gs_fade_get_active (GSFade *fade); + +gboolean gs_fade_get_enabled (GSFade *fade); +void gs_fade_set_enabled (GSFade *fade, + gboolean enabled); + +G_END_DECLS + +#endif /* __GS_FADE_H */ diff --git a/src/gs-grab-x11.c b/src/gs-grab-x11.c new file mode 100644 index 0000000..9eca1ec --- /dev/null +++ b/src/gs-grab-x11.c @@ -0,0 +1,672 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_XF86MISCSETGRABKEYSSTATE +# include +#endif /* HAVE_XF86MISCSETGRABKEYSSTATE */ + +#include "gs-window.h" +#include "gs-grab.h" +#include "gs-debug.h" + +static void gs_grab_class_init (GSGrabClass *klass); +static void gs_grab_init (GSGrab *grab); +static void gs_grab_finalize (GObject *object); + +#define GS_GRAB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_GRAB, GSGrabPrivate)) + +G_DEFINE_TYPE (GSGrab, gs_grab, G_TYPE_OBJECT) + +static gpointer grab_object = NULL; + +struct GSGrabPrivate +{ + guint mouse_hide_cursor : 1; + GdkWindow *mouse_grab_window; + GdkWindow *keyboard_grab_window; + GdkScreen *mouse_grab_screen; + GdkScreen *keyboard_grab_screen; + + GtkWidget *invisible; +}; + +static GdkCursor * +get_cursor (void) +{ + GdkBitmap *empty_bitmap; + GdkCursor *cursor; + GdkColor useless; + char invisible_cursor_bits [] = { 0x0 }; + + useless.red = useless.green = useless.blue = 0; + useless.pixel = 0; + + empty_bitmap = gdk_bitmap_create_from_data (NULL, + invisible_cursor_bits, + 1, 1); + + cursor = gdk_cursor_new_from_pixmap (empty_bitmap, + empty_bitmap, + &useless, + &useless, 0, 0); + + g_object_unref (empty_bitmap); + + return cursor; +} + +static const char * +grab_string (int status) +{ + switch (status) + { + case GDK_GRAB_SUCCESS: + return "GrabSuccess"; + case GDK_GRAB_ALREADY_GRABBED: + return "AlreadyGrabbed"; + case GDK_GRAB_INVALID_TIME: + return "GrabInvalidTime"; + case GDK_GRAB_NOT_VIEWABLE: + return "GrabNotViewable"; + case GDK_GRAB_FROZEN: + return "GrabFrozen"; + default: + { + static char foo [255]; + sprintf (foo, "unknown status: %d", status); + return foo; + } + } +} + +#ifdef HAVE_XF86MISCSETGRABKEYSSTATE +/* This function enables and disables the Ctrl-Alt-KP_star and + Ctrl-Alt-KP_slash hot-keys, which (in XFree86 4.2) break any + grabs and/or kill the grabbing client. That would effectively + unlock the screen, so we don't like that. + + The Ctrl-Alt-KP_star and Ctrl-Alt-KP_slash hot-keys only exist + if AllowDeactivateGrabs and/or AllowClosedownGrabs are turned on + in XF86Config. I believe they are disabled by default. + + This does not affect any other keys (specifically Ctrl-Alt-BS or + Ctrl-Alt-F1) but I wish it did. Maybe it will someday. + */ +static void +xorg_lock_smasher_set_active (GSGrab *grab, + gboolean active) +{ + int status, event, error; + + if (!XF86MiscQueryExtension (GDK_DISPLAY (), &event, &error)) + { + gs_debug ("No XFree86-Misc extension present"); + return; + } + + if (active) + { + gs_debug ("Enabling the x.org grab smasher"); + } + else + { + gs_debug ("Disabling the x.org grab smasher"); + } + + gdk_error_trap_push (); + + status = XF86MiscSetGrabKeysState (GDK_DISPLAY (), active); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); + + if (active && status == MiscExtGrabStateAlready) + { + /* shut up, consider this success */ + status = MiscExtGrabStateSuccess; + } + + gs_debug ("XF86MiscSetGrabKeysState(%s) returned %s\n", + active ? "on" : "off", + (status == MiscExtGrabStateSuccess ? "MiscExtGrabStateSuccess" : + status == MiscExtGrabStateLocked ? "MiscExtGrabStateLocked" : + status == MiscExtGrabStateAlready ? "MiscExtGrabStateAlready" : + "unknown value")); +} +#else +static void +xorg_lock_smasher_set_active (GSGrab *grab, + gboolean active) +{ +} +#endif /* HAVE_XF86MISCSETGRABKEYSSTATE */ + +static int +gs_grab_get_keyboard (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen) +{ + GdkGrabStatus status; + + g_return_val_if_fail (window != NULL, FALSE); + g_return_val_if_fail (screen != NULL, FALSE); + + gs_debug ("Grabbing keyboard widget=%X", (guint32) GDK_WINDOW_XID (window)); + status = gdk_keyboard_grab (window, FALSE, GDK_CURRENT_TIME); + + if (status == GDK_GRAB_SUCCESS) + { + if (grab->priv->keyboard_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + } + grab->priv->keyboard_grab_window = window; + + g_object_add_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + + grab->priv->keyboard_grab_screen = screen; + } + else + { + gs_debug ("Couldn't grab keyboard! (%s)", grab_string (status)); + } + + return status; +} + +static int +gs_grab_get_mouse (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + GdkGrabStatus status; + GdkCursor *cursor; + + g_return_val_if_fail (window != NULL, FALSE); + g_return_val_if_fail (screen != NULL, FALSE); + + cursor = get_cursor (); + + gs_debug ("Grabbing mouse widget=%X", (guint32) GDK_WINDOW_XID (window)); + status = gdk_pointer_grab (window, TRUE, 0, NULL, + (hide_cursor ? cursor : NULL), + GDK_CURRENT_TIME); + + if (status == GDK_GRAB_SUCCESS) + { + if (grab->priv->mouse_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + } + grab->priv->mouse_grab_window = window; + + g_object_add_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + + grab->priv->mouse_grab_screen = screen; + grab->priv->mouse_hide_cursor = hide_cursor; + } + + gdk_cursor_unref (cursor); + + return status; +} + +void +gs_grab_keyboard_reset (GSGrab *grab) +{ + if (grab->priv->keyboard_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + } + grab->priv->keyboard_grab_window = NULL; + grab->priv->keyboard_grab_screen = NULL; +} + +static gboolean +gs_grab_release_keyboard (GSGrab *grab) +{ + gs_debug ("Ungrabbing keyboard"); + gdk_keyboard_ungrab (GDK_CURRENT_TIME); + + gs_grab_keyboard_reset (grab); + + return TRUE; +} + +void +gs_grab_mouse_reset (GSGrab *grab) +{ + if (grab->priv->mouse_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + } + + grab->priv->mouse_grab_window = NULL; + grab->priv->mouse_grab_screen = NULL; +} + +gboolean +gs_grab_release_mouse (GSGrab *grab) +{ + gs_debug ("Ungrabbing pointer"); + gdk_pointer_ungrab (GDK_CURRENT_TIME); + + gs_grab_mouse_reset (grab); + + return TRUE; +} + +static gboolean +gs_grab_move_mouse (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean result; + GdkWindow *old_window; + GdkScreen *old_screen; + gboolean old_hide_cursor; + + /* if the pointer is not grabbed and we have a + mouse_grab_window defined then we lost the grab */ + if (! gdk_pointer_is_grabbed ()) + { + gs_grab_mouse_reset (grab); + } + + if (grab->priv->mouse_grab_window == window) + { + gs_debug ("Window %X is already grabbed, skipping", + (guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window)); + return TRUE; + } + +#if 0 + gs_debug ("Intentionally skipping move pointer grabs"); + /* FIXME: GTK doesn't like having the pointer grabbed */ + return TRUE; +#else + if (grab->priv->mouse_grab_window) + { + gs_debug ("Moving pointer grab from %X to %X", + (guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window), + (guint32) GDK_WINDOW_XID (window)); + } + else + { + gs_debug ("Getting pointer grab on %X", + (guint32) GDK_WINDOW_XID (window)); + } +#endif + + gs_debug ("*** doing X server grab"); + gdk_x11_grab_server (); + + old_window = grab->priv->mouse_grab_window; + old_screen = grab->priv->mouse_grab_screen; + old_hide_cursor = grab->priv->mouse_hide_cursor; + + if (old_window) + { + gs_grab_release_mouse (grab); + } + + result = gs_grab_get_mouse (grab, window, screen, hide_cursor); + + if (result != GDK_GRAB_SUCCESS) + { + sleep (1); + result = gs_grab_get_mouse (grab, window, screen, hide_cursor); + } + + if ((result != GDK_GRAB_SUCCESS) && old_window) + { + gs_debug ("Could not grab mouse for new window. Resuming previous grab."); + gs_grab_get_mouse (grab, old_window, old_screen, old_hide_cursor); + } + + gs_debug ("*** releasing X server grab"); + gdk_x11_ungrab_server (); + gdk_flush (); + + return (result == GDK_GRAB_SUCCESS); +} + +static gboolean +gs_grab_move_keyboard (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen) +{ + gboolean result; + GdkWindow *old_window; + GdkScreen *old_screen; + + if (grab->priv->keyboard_grab_window == window) + { + gs_debug ("Window %X is already grabbed, skipping", + (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window)); + return TRUE; + } + + if (grab->priv->keyboard_grab_window != NULL) + { + gs_debug ("Moving keyboard grab from %X to %X", + (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window), + (guint32) GDK_WINDOW_XID (window)); + } + else + { + gs_debug ("Getting keyboard grab on %X", + (guint32) GDK_WINDOW_XID (window)); + + } + + gs_debug ("*** doing X server grab"); + gdk_x11_grab_server (); + + old_window = grab->priv->keyboard_grab_window; + old_screen = grab->priv->keyboard_grab_screen; + + if (old_window) + { + gs_grab_release_keyboard (grab); + } + + result = gs_grab_get_keyboard (grab, window, screen); + + if (result != GDK_GRAB_SUCCESS) + { + sleep (1); + result = gs_grab_get_keyboard (grab, window, screen); + } + + if ((result != GDK_GRAB_SUCCESS) && old_window) + { + gs_debug ("Could not grab keyboard for new window. Resuming previous grab."); + gs_grab_get_keyboard (grab, old_window, old_screen); + } + + gs_debug ("*** releasing X server grab"); + gdk_x11_ungrab_server (); + gdk_flush (); + + return (result == GDK_GRAB_SUCCESS); +} + +static void +gs_grab_nuke_focus (void) +{ + Window focus = 0; + int rev = 0; + + gs_debug ("Nuking focus"); + + gdk_error_trap_push (); + + XGetInputFocus (GDK_DISPLAY (), &focus, &rev); + + XSetInputFocus (GDK_DISPLAY (), None, RevertToNone, CurrentTime); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +} + +void +gs_grab_release (GSGrab *grab) +{ + gs_debug ("Releasing all grabs"); + + gs_grab_release_mouse (grab); + gs_grab_release_keyboard (grab); + + /* FIXME: is it right to enable this ? */ + xorg_lock_smasher_set_active (grab, TRUE); + + gdk_display_sync (gdk_display_get_default ()); + gdk_flush (); +} + +gboolean +gs_grab_grab_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean mstatus = FALSE; + gboolean kstatus = FALSE; + int i; + int retries = 4; + gboolean focus_fuckus = FALSE; + +AGAIN: + + for (i = 0; i < retries; i++) + { + kstatus = gs_grab_get_keyboard (grab, window, screen); + if (kstatus == GDK_GRAB_SUCCESS) + { + break; + } + + /* else, wait a second and try to grab again. */ + sleep (1); + } + + if (kstatus != GDK_GRAB_SUCCESS) + { + if (!focus_fuckus) + { + focus_fuckus = TRUE; + gs_grab_nuke_focus (); + goto AGAIN; + } + } + + for (i = 0; i < retries; i++) + { + mstatus = gs_grab_get_mouse (grab, window, screen, hide_cursor); + if (mstatus == GDK_GRAB_SUCCESS) + { + break; + } + + /* else, wait a second and try to grab again. */ + sleep (1); + } + + if (mstatus != GDK_GRAB_SUCCESS) + { + gs_debug ("Couldn't grab pointer! (%s)", + grab_string (mstatus)); + } + +#if 0 + /* FIXME: release the pointer grab so GTK will work */ + gs_grab_release_mouse (grab); +#endif + + /* When should we allow blanking to proceed? The current theory + is that both a keyboard grab and a mouse grab are mandatory + + - If we don't have a keyboard grab, then we won't be able to + read a password to unlock, so the kbd grab is manditory. + + - If we don't have a mouse grab, then we might not see mouse + clicks as a signal to unblank, on-screen widgets won't work ideally, + and gs_grab_move_to_window() will spin forever when it gets called. + */ + + if (kstatus != GDK_GRAB_SUCCESS || mstatus != GDK_GRAB_SUCCESS) + { + /* Do not blank without a keyboard and mouse grabs. */ + + /* Release keyboard or mouse which was grabbed. */ + if (kstatus == GDK_GRAB_SUCCESS) + { + gs_grab_release_keyboard (grab); + } + if (mstatus == GDK_GRAB_SUCCESS) + { + gs_grab_release_mouse (grab); + } + + return FALSE; + } + + /* Grab is good, go ahead and blank. */ + return TRUE; +} + +/* this is used to grab the keyboard and mouse to the root */ +gboolean +gs_grab_grab_root (GSGrab *grab, + gboolean hide_cursor) +{ + GdkDisplay *display; + GdkWindow *root; + GdkScreen *screen; + gboolean res; + + gs_debug ("Grabbing the root window"); + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, NULL, NULL, NULL); + root = gdk_screen_get_root_window (screen); + + res = gs_grab_grab_window (grab, root, screen, hide_cursor); + + return res; +} + +/* this is used to grab the keyboard and mouse to an offscreen window */ +gboolean +gs_grab_grab_offscreen (GSGrab *grab, + gboolean hide_cursor) +{ + GdkScreen *screen; + gboolean res; + + gs_debug ("Grabbing an offscreen window"); + + screen = gtk_invisible_get_screen (GTK_INVISIBLE (grab->priv->invisible)); + res = gs_grab_grab_window (grab, grab->priv->invisible->window, screen, hide_cursor); + + return res; +} + +/* This is similar to gs_grab_grab_window but doesn't fail */ +void +gs_grab_move_to_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean result = FALSE; + + g_return_if_fail (GS_IS_GRAB (grab)); + + xorg_lock_smasher_set_active (grab, FALSE); + + do + { + result = gs_grab_move_keyboard (grab, window, screen); + gdk_flush (); + } + while (!result); + + do + { + result = gs_grab_move_mouse (grab, window, screen, hide_cursor); + gdk_flush (); + } + while (!result); +} + +static void +gs_grab_class_init (GSGrabClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_grab_finalize; + + g_type_class_add_private (klass, sizeof (GSGrabPrivate)); +} + +static void +gs_grab_init (GSGrab *grab) +{ + grab->priv = GS_GRAB_GET_PRIVATE (grab); + + grab->priv->mouse_hide_cursor = FALSE; + grab->priv->invisible = gtk_invisible_new (); + gtk_widget_show (grab->priv->invisible); +} + +static void +gs_grab_finalize (GObject *object) +{ + GSGrab *grab; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_GRAB (object)); + + grab = GS_GRAB (object); + + g_return_if_fail (grab->priv != NULL); + + gtk_widget_destroy (grab->priv->invisible); + + G_OBJECT_CLASS (gs_grab_parent_class)->finalize (object); +} + +GSGrab * +gs_grab_new (void) +{ + if (grab_object) + { + g_object_ref (grab_object); + } + else + { + grab_object = g_object_new (GS_TYPE_GRAB, NULL); + g_object_add_weak_pointer (grab_object, + (gpointer *) &grab_object); + } + + return GS_GRAB (grab_object); +} diff --git a/src/gs-grab-x11.c.orig b/src/gs-grab-x11.c.orig new file mode 100644 index 0000000..e6e7f22 --- /dev/null +++ b/src/gs-grab-x11.c.orig @@ -0,0 +1,672 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_XF86MISCSETGRABKEYSSTATE +# include +#endif /* HAVE_XF86MISCSETGRABKEYSSTATE */ + +#include "gs-window.h" +#include "gs-grab.h" +#include "gs-debug.h" + +static void gs_grab_class_init (GSGrabClass *klass); +static void gs_grab_init (GSGrab *grab); +static void gs_grab_finalize (GObject *object); + +#define GS_GRAB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_GRAB, GSGrabPrivate)) + +G_DEFINE_TYPE (GSGrab, gs_grab, G_TYPE_OBJECT) + +static gpointer grab_object = NULL; + +struct GSGrabPrivate +{ + guint mouse_hide_cursor : 1; + GdkWindow *mouse_grab_window; + GdkWindow *keyboard_grab_window; + GdkScreen *mouse_grab_screen; + GdkScreen *keyboard_grab_screen; + + GtkWidget *invisible; +}; + +static GdkCursor * +get_cursor (void) +{ + GdkBitmap *empty_bitmap; + GdkCursor *cursor; + GdkColor useless; + char invisible_cursor_bits [] = { 0x0 }; + + useless.red = useless.green = useless.blue = 0; + useless.pixel = 0; + + empty_bitmap = gdk_bitmap_create_from_data (NULL, + invisible_cursor_bits, + 1, 1); + + cursor = gdk_cursor_new_from_pixmap (empty_bitmap, + empty_bitmap, + &useless, + &useless, 0, 0); + + g_object_unref (empty_bitmap); + + return cursor; +} + +static const char * +grab_string (int status) +{ + switch (status) + { + case GDK_GRAB_SUCCESS: + return "GrabSuccess"; + case GDK_GRAB_ALREADY_GRABBED: + return "AlreadyGrabbed"; + case GDK_GRAB_INVALID_TIME: + return "GrabInvalidTime"; + case GDK_GRAB_NOT_VIEWABLE: + return "GrabNotViewable"; + case GDK_GRAB_FROZEN: + return "GrabFrozen"; + default: + { + static char foo [255]; + sprintf (foo, "unknown status: %d", status); + return foo; + } + } +} + +#ifdef HAVE_XF86MISCSETGRABKEYSSTATE +/* This function enables and disables the Ctrl-Alt-KP_star and + Ctrl-Alt-KP_slash hot-keys, which (in XFree86 4.2) break any + grabs and/or kill the grabbing client. That would effectively + unlock the screen, so we don't like that. + + The Ctrl-Alt-KP_star and Ctrl-Alt-KP_slash hot-keys only exist + if AllowDeactivateGrabs and/or AllowClosedownGrabs are turned on + in XF86Config. I believe they are disabled by default. + + This does not affect any other keys (specifically Ctrl-Alt-BS or + Ctrl-Alt-F1) but I wish it did. Maybe it will someday. + */ +static void +xorg_lock_smasher_set_active (GSGrab *grab, + gboolean active) +{ + int status, event, error; + + if (!XF86MiscQueryExtension (GDK_DISPLAY (), &event, &error)) + { + gs_debug ("No XFree86-Misc extension present"); + return; + } + + if (active) + { + gs_debug ("Enabling the x.org grab smasher"); + } + else + { + gs_debug ("Disabling the x.org grab smasher"); + } + + gdk_error_trap_push (); + + status = XF86MiscSetGrabKeysState (GDK_DISPLAY (), active); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); + + if (active && status == MiscExtGrabStateAlready) + { + /* shut up, consider this success */ + status = MiscExtGrabStateSuccess; + } + + gs_debug ("XF86MiscSetGrabKeysState(%s) returned %s\n", + active ? "on" : "off", + (status == MiscExtGrabStateSuccess ? "MiscExtGrabStateSuccess" : + status == MiscExtGrabStateLocked ? "MiscExtGrabStateLocked" : + status == MiscExtGrabStateAlready ? "MiscExtGrabStateAlready" : + "unknown value")); +} +#else +static void +xorg_lock_smasher_set_active (GSGrab *grab, + gboolean active) +{ +} +#endif /* HAVE_XF86MISCSETGRABKEYSSTATE */ + +static int +gs_grab_get_keyboard (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen) +{ + GdkGrabStatus status; + + g_return_val_if_fail (window != NULL, FALSE); + g_return_val_if_fail (screen != NULL, FALSE); + + gs_debug ("Grabbing keyboard widget=%X", (guint32) GDK_WINDOW_XID (window)); + status = gdk_keyboard_grab (window, FALSE, GDK_CURRENT_TIME); + + if (status == GDK_GRAB_SUCCESS) + { + if (grab->priv->keyboard_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + } + grab->priv->keyboard_grab_window = window; + + g_object_add_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + + grab->priv->keyboard_grab_screen = screen; + } + else + { + gs_debug ("Couldn't grab keyboard! (%s)", grab_string (status)); + } + + return status; +} + +static int +gs_grab_get_mouse (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + GdkGrabStatus status; + GdkCursor *cursor; + + g_return_val_if_fail (window != NULL, FALSE); + g_return_val_if_fail (screen != NULL, FALSE); + + cursor = get_cursor (); + + gs_debug ("Grabbing mouse widget=%X", (guint32) GDK_WINDOW_XID (window)); + status = gdk_pointer_grab (window, TRUE, 0, NULL, + (hide_cursor ? cursor : NULL), + GDK_CURRENT_TIME); + + if (status == GDK_GRAB_SUCCESS) + { + if (grab->priv->mouse_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + } + grab->priv->mouse_grab_window = window; + + g_object_add_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + + grab->priv->mouse_grab_screen = screen; + grab->priv->mouse_hide_cursor = hide_cursor; + } + + gdk_cursor_unref (cursor); + + return status; +} + +void +gs_grab_keyboard_reset (GSGrab *grab) +{ + if (grab->priv->keyboard_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window), + (gpointer *) &grab->priv->keyboard_grab_window); + } + grab->priv->keyboard_grab_window = NULL; + grab->priv->keyboard_grab_screen = NULL; +} + +static gboolean +gs_grab_release_keyboard (GSGrab *grab) +{ + gs_debug ("Ungrabbing keyboard"); + gdk_keyboard_ungrab (GDK_CURRENT_TIME); + + gs_grab_keyboard_reset (grab); + + return TRUE; +} + +void +gs_grab_mouse_reset (GSGrab *grab) +{ + if (grab->priv->mouse_grab_window != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (grab->priv->mouse_grab_window), + (gpointer *) &grab->priv->mouse_grab_window); + } + + grab->priv->mouse_grab_window = NULL; + grab->priv->mouse_grab_screen = NULL; +} + +gboolean +gs_grab_release_mouse (GSGrab *grab) +{ + gs_debug ("Ungrabbing pointer"); + gdk_pointer_ungrab (GDK_CURRENT_TIME); + + gs_grab_mouse_reset (grab); + + return TRUE; +} + +static gboolean +gs_grab_move_mouse (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean result; + GdkWindow *old_window; + GdkScreen *old_screen; + gboolean old_hide_cursor; + + /* if the pointer is not grabbed and we have a + mouse_grab_window defined then we lost the grab */ + if (! gdk_pointer_is_grabbed ()) + { + gs_grab_mouse_reset (grab); + } + + if (grab->priv->mouse_grab_window == window) + { + gs_debug ("Window %X is already grabbed, skipping", + (guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window)); + return TRUE; + } + +#if 0 + gs_debug ("Intentionally skipping move pointer grabs"); + /* FIXME: GTK doesn't like having the pointer grabbed */ + return TRUE; +#else + if (grab->priv->mouse_grab_window) + { + gs_debug ("Moving pointer grab from %X to %X", + (guint32) GDK_WINDOW_XID (grab->priv->mouse_grab_window), + (guint32) GDK_WINDOW_XID (window)); + } + else + { + gs_debug ("Getting pointer grab on %X", + (guint32) GDK_WINDOW_XID (window)); + } +#endif + + gs_debug ("*** doing X server grab"); + gdk_x11_grab_server (); + + old_window = grab->priv->mouse_grab_window; + old_screen = grab->priv->mouse_grab_screen; + old_hide_cursor = grab->priv->mouse_hide_cursor; + + if (old_window) + { + gs_grab_release_mouse (grab); + } + + result = gs_grab_get_mouse (grab, window, screen, hide_cursor); + + if (result != GDK_GRAB_SUCCESS) + { + sleep (1); + result = gs_grab_get_mouse (grab, window, screen, hide_cursor); + } + + if ((result != GDK_GRAB_SUCCESS) && old_window) + { + gs_debug ("Could not grab mouse for new window. Resuming previous grab."); + gs_grab_get_mouse (grab, old_window, old_screen, old_hide_cursor); + } + + gs_debug ("*** releasing X server grab"); + gdk_x11_ungrab_server (); + gdk_flush (); + + return (result == GDK_GRAB_SUCCESS); +} + +static gboolean +gs_grab_move_keyboard (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen) +{ + gboolean result; + GdkWindow *old_window; + GdkScreen *old_screen; + + if (grab->priv->keyboard_grab_window == window) + { + gs_debug ("Window %X is already grabbed, skipping", + (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window)); + return TRUE; + } + + if (grab->priv->keyboard_grab_window != NULL) + { + gs_debug ("Moving keyboard grab from %X to %X", + (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window), + (guint32) GDK_WINDOW_XID (window)); + } + else + { + gs_debug ("Getting keyboard grab on %X", + (guint32) GDK_WINDOW_XID (window)); + + } + + gs_debug ("*** doing X server grab"); + gdk_x11_grab_server (); + + old_window = grab->priv->keyboard_grab_window; + old_screen = grab->priv->keyboard_grab_screen; + + if (old_window) + { + gs_grab_release_keyboard (grab); + } + + result = gs_grab_get_keyboard (grab, window, screen); + + if (result != GDK_GRAB_SUCCESS) + { + sleep (1); + result = gs_grab_get_keyboard (grab, window, screen); + } + + if ((result != GDK_GRAB_SUCCESS) && old_window) + { + gs_debug ("Could not grab keyboard for new window. Resuming previous grab."); + gs_grab_get_keyboard (grab, old_window, old_screen); + } + + gs_debug ("*** releasing X server grab"); + gdk_x11_ungrab_server (); + gdk_flush (); + + return (result == GDK_GRAB_SUCCESS); +} + +static void +gs_grab_nuke_focus (void) +{ + Window focus = 0; + int rev = 0; + + gs_debug ("Nuking focus"); + + gdk_error_trap_push (); + + XGetInputFocus (GDK_DISPLAY (), &focus, &rev); + + XSetInputFocus (GDK_DISPLAY (), None, RevertToNone, CurrentTime); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +} + +void +gs_grab_release (GSGrab *grab) +{ + gs_debug ("Releasing all grabs"); + + gs_grab_release_mouse (grab); + gs_grab_release_keyboard (grab); + + /* FIXME: is it right to enable this ? */ + xorg_lock_smasher_set_active (grab, TRUE); + + gdk_display_sync (gdk_display_get_default ()); + gdk_flush (); +} + +gboolean +gs_grab_grab_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean mstatus = FALSE; + gboolean kstatus = FALSE; + int i; + int retries = 4; + gboolean focus_fuckus = FALSE; + +AGAIN: + + for (i = 0; i < retries; i++) + { + kstatus = gs_grab_get_keyboard (grab, window, screen); + if (kstatus == GDK_GRAB_SUCCESS) + { + break; + } + + /* else, wait a second and try to grab again. */ + sleep (1); + } + + if (kstatus != GDK_GRAB_SUCCESS) + { + if (!focus_fuckus) + { + focus_fuckus = TRUE; + gs_grab_nuke_focus (); + goto AGAIN; + } + } + + for (i = 0; i < retries; i++) + { + mstatus = gs_grab_get_mouse (grab, window, screen, hide_cursor); + if (mstatus == GDK_GRAB_SUCCESS) + { + break; + } + + /* else, wait a second and try to grab again. */ + sleep (1); + } + + if (mstatus != GDK_GRAB_SUCCESS) + { + gs_debug ("Couldn't grab pointer! (%s)", + grab_string (mstatus)); + } + +#if 0 + /* FIXME: release the pointer grab so GTK will work */ + gs_grab_release_mouse (grab); +#endif + + /* When should we allow blanking to proceed? The current theory + is that both a keyboard grab and a mouse grab are mandatory + + - If we don't have a keyboard grab, then we won't be able to + read a password to unlock, so the kbd grab is manditory. + + - If we don't have a mouse grab, then we might not see mouse + clicks as a signal to unblank, on-screen widgets won't work ideally, + and gs_grab_move_to_window() will spin forever when it gets called. + */ + + if (kstatus != GDK_GRAB_SUCCESS || mstatus != GDK_GRAB_SUCCESS) + { + /* Do not blank without a keyboard and mouse grabs. */ + + /* Release keyboard or mouse which was grabbed. */ + if (kstatus == GDK_GRAB_SUCCESS) + { + gs_grab_release_keyboard (grab); + } + if (mstatus == GDK_GRAB_SUCCESS) + { + gs_grab_release_mouse (grab); + } + + return FALSE; + } + + /* Grab is good, go ahead and blank. */ + return TRUE; +} + +/* this is used to grab the keyboard and mouse to the root */ +gboolean +gs_grab_grab_root (GSGrab *grab, + gboolean hide_cursor) +{ + GdkDisplay *display; + GdkWindow *root; + GdkScreen *screen; + gboolean res; + + gs_debug ("Grabbing the root window"); + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, NULL, NULL, NULL); + root = gdk_screen_get_root_window (screen); + + res = gs_grab_grab_window (grab, root, screen, hide_cursor); + + return res; +} + +/* this is used to grab the keyboard and mouse to an offscreen window */ +gboolean +gs_grab_grab_offscreen (GSGrab *grab, + gboolean hide_cursor) +{ + GdkScreen *screen; + gboolean res; + + gs_debug ("Grabbing an offscreen window"); + + screen = gtk_invisible_get_screen (GTK_INVISIBLE (grab->priv->invisible)); + res = gs_grab_grab_window (grab, grab->priv->invisible->window, screen, hide_cursor); + + return res; +} + +/* This is similar to gs_grab_grab_window but doesn't fail */ +void +gs_grab_move_to_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor) +{ + gboolean result = FALSE; + + g_return_if_fail (GS_IS_GRAB (grab)); + + xorg_lock_smasher_set_active (grab, FALSE); + + do + { + result = gs_grab_move_keyboard (grab, window, screen); + gdk_flush (); + } + while (!result); + + do + { + result = gs_grab_move_mouse (grab, window, screen, hide_cursor); + gdk_flush (); + } + while (!result); +} + +static void +gs_grab_class_init (GSGrabClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_grab_finalize; + + g_type_class_add_private (klass, sizeof (GSGrabPrivate)); +} + +static void +gs_grab_init (GSGrab *grab) +{ + grab->priv = GS_GRAB_GET_PRIVATE (grab); + + grab->priv->mouse_hide_cursor = FALSE; + grab->priv->invisible = gtk_invisible_new (); + gtk_widget_show (grab->priv->invisible); +} + +static void +gs_grab_finalize (GObject *object) +{ + GSGrab *grab; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_GRAB (object)); + + grab = GS_GRAB (object); + + g_return_if_fail (grab->priv != NULL); + + gtk_widget_destroy (grab->priv->invisible); + + G_OBJECT_CLASS (gs_grab_parent_class)->finalize (object); +} + +GSGrab * +gs_grab_new (void) +{ + if (grab_object) + { + g_object_ref (grab_object); + } + else + { + grab_object = g_object_new (GS_TYPE_GRAB, NULL); + g_object_add_weak_pointer (grab_object, + (gpointer *) &grab_object); + } + + return GS_GRAB (grab_object); +} diff --git a/src/gs-grab.h b/src/gs-grab.h new file mode 100644 index 0000000..4717f49 --- /dev/null +++ b/src/gs-grab.h @@ -0,0 +1,79 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_GRAB_H +#define __GS_GRAB_H + +#include +#include + +G_BEGIN_DECLS + +#define GS_TYPE_GRAB (gs_grab_get_type ()) +#define GS_GRAB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_GRAB, GSGrab)) +#define GS_GRAB_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_GRAB, GSGrabClass)) +#define GS_IS_GRAB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_GRAB)) +#define GS_IS_GRAB_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_GRAB)) +#define GS_GRAB_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_GRAB, GSGrabClass)) + +typedef struct GSGrabPrivate GSGrabPrivate; + +typedef struct +{ + GObject parent; + GSGrabPrivate *priv; +} GSGrab; + +typedef struct +{ + GObjectClass parent_class; + +} GSGrabClass; + +GType gs_grab_get_type (void); + +GSGrab * gs_grab_new (void); + +void gs_grab_release (GSGrab *grab); +gboolean gs_grab_release_mouse (GSGrab *grab); + +gboolean gs_grab_grab_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor); + +gboolean gs_grab_grab_root (GSGrab *grab, + gboolean hide_cursor); +gboolean gs_grab_grab_offscreen (GSGrab *grab, + gboolean hide_cursor); + +void gs_grab_move_to_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor); + +void gs_grab_mouse_reset (GSGrab *grab); +void gs_grab_keyboard_reset (GSGrab *grab); + +G_END_DECLS + +#endif /* __GS_GRAB_H */ diff --git a/src/gs-grab.h.orig b/src/gs-grab.h.orig new file mode 100644 index 0000000..a910403 --- /dev/null +++ b/src/gs-grab.h.orig @@ -0,0 +1,79 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_GRAB_H +#define __GS_GRAB_H + +#include +#include + +G_BEGIN_DECLS + +#define GS_TYPE_GRAB (gs_grab_get_type ()) +#define GS_GRAB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_GRAB, GSGrab)) +#define GS_GRAB_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_GRAB, GSGrabClass)) +#define GS_IS_GRAB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_GRAB)) +#define GS_IS_GRAB_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_GRAB)) +#define GS_GRAB_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_GRAB, GSGrabClass)) + +typedef struct GSGrabPrivate GSGrabPrivate; + +typedef struct +{ + GObject parent; + GSGrabPrivate *priv; +} GSGrab; + +typedef struct +{ + GObjectClass parent_class; + +} GSGrabClass; + +GType gs_grab_get_type (void); + +GSGrab * gs_grab_new (void); + +void gs_grab_release (GSGrab *grab); +gboolean gs_grab_release_mouse (GSGrab *grab); + +gboolean gs_grab_grab_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor); + +gboolean gs_grab_grab_root (GSGrab *grab, + gboolean hide_cursor); +gboolean gs_grab_grab_offscreen (GSGrab *grab, + gboolean hide_cursor); + +void gs_grab_move_to_window (GSGrab *grab, + GdkWindow *window, + GdkScreen *screen, + gboolean hide_cursor); + +void gs_grab_mouse_reset (GSGrab *grab); +void gs_grab_keyboard_reset (GSGrab *grab); + +G_END_DECLS + +#endif /* __GS_GRAB_H */ diff --git a/src/gs-job.c b/src/gs-job.c new file mode 100644 index 0000000..30d1f34 --- /dev/null +++ b/src/gs-job.c @@ -0,0 +1,567 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS) +#include +#endif + +#include +#include +#include +#include + +#include "gs-debug.h" +#include "gs-job.h" + +#include "subprocs.h" + +static void gs_job_class_init (GSJobClass *klass); +static void gs_job_init (GSJob *job); +static void gs_job_finalize (GObject *object); + +#define GS_JOB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_JOB, GSJobPrivate)) + +typedef enum +{ + GS_JOB_INVALID, + GS_JOB_RUNNING, + GS_JOB_STOPPED, + GS_JOB_KILLED, + GS_JOB_DEAD +} GSJobStatus; + +struct GSJobPrivate +{ + GtkWidget *widget; + + GSJobStatus status; + gint pid; + guint watch_id; + + char *command; +}; + +G_DEFINE_TYPE (GSJob, gs_job, G_TYPE_OBJECT) + +static char * +widget_get_id_string (GtkWidget *widget) +{ + char *id = NULL; + + g_return_val_if_fail (widget != NULL, NULL); + + id = g_strdup_printf ("0x%X", + (guint32)GDK_WINDOW_XID (widget->window)); + return id; +} + +static void +gs_job_class_init (GSJobClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_job_finalize; + + g_type_class_add_private (klass, sizeof (GSJobPrivate)); +} + +static void +gs_job_init (GSJob *job) +{ + job->priv = GS_JOB_GET_PRIVATE (job); +} + +/* adapted from gspawn.c */ +static int +wait_on_child (int pid) +{ + int status; + +wait_again: + if (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + goto wait_again; + } + else if (errno == ECHILD) + { + ; /* do nothing, child already reaped */ + } + else + { + gs_debug ("waitpid () should not fail in 'GSJob'"); + } + } + + return status; +} + +static void +gs_job_died (GSJob *job) +{ + if (job->priv->pid > 0) + { + int exit_status; + + gs_debug ("Waiting on process %d", job->priv->pid); + exit_status = wait_on_child (job->priv->pid); + + job->priv->status = GS_JOB_DEAD; + + if (WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) != 0)) + { + gs_debug ("Wait on child process failed"); + } + else + { + /* exited normally */ + } + } + g_spawn_close_pid (job->priv->pid); + job->priv->pid = 0; + + gs_debug ("Job died"); +} + +static void +gs_job_finalize (GObject *object) +{ + GSJob *job; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_JOB (object)); + + job = GS_JOB (object); + + g_return_if_fail (job->priv != NULL); + + if (job->priv->pid > 0) + { + signal_pid (job->priv->pid, SIGTERM); + gs_job_died (job); + } + + g_free (job->priv->command); + job->priv->command = NULL; + + G_OBJECT_CLASS (gs_job_parent_class)->finalize (object); +} + +void +gs_job_set_widget (GSJob *job, + GtkWidget *widget) +{ + g_return_if_fail (job != NULL); + g_return_if_fail (GS_IS_JOB (job)); + + if (widget != job->priv->widget) + { + job->priv->widget = widget; + + /* restart job */ + if (gs_job_is_running (job)) + { + gs_job_stop (job); + gs_job_start (job); + } + } +} + +gboolean +gs_job_set_command (GSJob *job, + const char *command) +{ + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("Setting command for job: '%s'", + command != NULL ? command : "NULL"); + + g_free (job->priv->command); + job->priv->command = g_strdup (command); + + return TRUE; +} + +GSJob * +gs_job_new (void) +{ + GObject *job; + + job = g_object_new (GS_TYPE_JOB, NULL); + + return GS_JOB (job); +} + +GSJob * +gs_job_new_for_widget (GtkWidget *widget) +{ + GObject *job; + + job = g_object_new (GS_TYPE_JOB, NULL); + + gs_job_set_widget (GS_JOB (job), widget); + + return GS_JOB (job); +} + +static void +nice_process (int pid, + int nice_level) +{ + g_return_if_fail (pid > 0); + + if (nice_level == 0) + { + return; + } + +#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS) + gs_debug ("Setting child process priority to: %d", nice_level); + if (setpriority (PRIO_PROCESS, pid, nice_level) != 0) + { + gs_debug ("setpriority(PRIO_PROCESS, %lu, %d) failed", + (unsigned long) pid, nice_level); + } +#else + gs_debug ("don't know how to change process priority on this system."); +#endif +} + +static GPtrArray * +get_env_vars (GtkWidget *widget) +{ + GPtrArray *env; + char *str; + int i; + static const char *allowed_env_vars [] = + { + "PATH", + "SESSION_MANAGER", + "XAUTHORITY", + "XAUTHLOCALHOSTNAME", + "LANG", + "LANGUAGE", + "DBUS_SESSION_BUS_ADDRESS" + }; + + env = g_ptr_array_new (); + + str = gdk_screen_make_display_name (gtk_widget_get_screen (widget)); + g_ptr_array_add (env, g_strdup_printf ("DISPLAY=%s", str)); + g_free (str); + + g_ptr_array_add (env, g_strdup_printf ("HOME=%s", + g_get_home_dir ())); + + for (i = 0; i < G_N_ELEMENTS (allowed_env_vars); i++) + { + const char *var; + const char *val; + var = allowed_env_vars [i]; + val = g_getenv (var); + if (val != NULL) + { + g_ptr_array_add (env, g_strdup_printf ("%s=%s", + var, + val)); + } + } + + str = widget_get_id_string (widget); + g_ptr_array_add (env, g_strdup_printf ("XSCREENSAVER_WINDOW=%s", str)); + g_free (str); + + g_ptr_array_add (env, NULL); + + return env; +} + +static gboolean +spawn_on_widget (GtkWidget *widget, + const char *command, + int *pid, + GIOFunc watch_func, + gpointer user_data, + guint *watch_id) +{ + char **argv; + GPtrArray *env; + gboolean result; + GIOChannel *channel; + GError *error = NULL; + int standard_error; + int child_pid; + int id; + int i; + + if (command == NULL) + { + return FALSE; + } + + if (! g_shell_parse_argv (command, NULL, &argv, &error)) + { + gs_debug ("Could not parse command: %s", error->message); + g_error_free (error); + return FALSE; + } + + env = get_env_vars (widget); + + error = NULL; + result = gdk_spawn_on_screen_with_pipes (gtk_widget_get_screen (widget), + NULL, + argv, + (char **)env->pdata, + G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, + NULL, + NULL, + &child_pid, + NULL, + NULL, + &standard_error, + &error); + for (i = 0; i < env->len; i++) + { + g_free (g_ptr_array_index (env, i)); + } + g_ptr_array_free (env, TRUE); + + if (! result) + { + gs_debug ("Could not start command '%s': %s", command, error->message); + g_error_free (error); + g_strfreev (argv); + return FALSE; + } + + g_strfreev (argv); + + nice_process (child_pid, 10); + + if (pid != NULL) + { + *pid = child_pid; + } + else + { + g_spawn_close_pid (child_pid); + } + + channel = g_io_channel_unix_new (standard_error); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + watch_func, + user_data); + if (watch_id != NULL) + { + *watch_id = id; + } + + g_io_channel_unref (channel); + + return result; +} + +static gboolean +command_watch (GIOChannel *source, + GIOCondition condition, + GSJob *job) +{ + GIOStatus status; + GError *error = NULL; + gboolean done = FALSE; + + g_return_val_if_fail (job != NULL, FALSE); + + if (condition & G_IO_IN) + { + char *str; + + status = g_io_channel_read_line (source, &str, NULL, NULL, &error); + + if (status == G_IO_STATUS_NORMAL) + { + gs_debug ("command output: %s", str); + + } + else if (status == G_IO_STATUS_EOF) + { + done = TRUE; + + } + else if (error != NULL) + { + gs_debug ("command error: %s", error->message); + g_error_free (error); + } + + g_free (str); + } + else if (condition & G_IO_HUP) + { + done = TRUE; + } + + if (done) + { + gs_job_died (job); + + job->priv->watch_id = 0; + return FALSE; + } + + return TRUE; +} + +gboolean +gs_job_is_running (GSJob *job) +{ + gboolean running; + + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + running = (job->priv->pid > 0); + + return running; +} + +gboolean +gs_job_start (GSJob *job) +{ + gboolean result; + + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("starting job"); + + if (job->priv->pid != 0) + { + gs_debug ("Cannot restart active job."); + return FALSE; + } + + if (job->priv->widget == NULL) + { + gs_debug ("Could not start job: screensaver window is not set."); + return FALSE; + } + + if (job->priv->command == NULL) + { + /* no warning here because a NULL command is interpreted + as a no-op job */ + gs_debug ("No command set for job."); + return FALSE; + } + + result = spawn_on_widget (job->priv->widget, + job->priv->command, + &job->priv->pid, + (GIOFunc)command_watch, + job, + &job->priv->watch_id); + + if (result) + { + job->priv->status = GS_JOB_RUNNING; + } + + return result; +} + +static void +remove_command_watch (GSJob *job) +{ + if (job->priv->watch_id != 0) + { + g_source_remove (job->priv->watch_id); + job->priv->watch_id = 0; + } +} + +gboolean +gs_job_stop (GSJob *job) +{ + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("stopping job"); + + if (job->priv->pid == 0) + { + gs_debug ("Could not stop job: pid not defined"); + return FALSE; + } + + if (job->priv->status == GS_JOB_STOPPED) + { + gs_job_suspend (job, FALSE); + } + + remove_command_watch (job); + + signal_pid (job->priv->pid, SIGTERM); + + job->priv->status = GS_JOB_KILLED; + + gs_job_died (job); + + return TRUE; +} + +gboolean +gs_job_suspend (GSJob *job, + gboolean suspend) +{ + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("suspending job"); + + if (job->priv->pid == 0) + { + return FALSE; + } + + signal_pid (job->priv->pid, (suspend ? SIGSTOP : SIGCONT)); + + job->priv->status = (suspend ? GS_JOB_STOPPED : GS_JOB_RUNNING); + + return TRUE; +} diff --git a/src/gs-job.c.orig b/src/gs-job.c.orig new file mode 100644 index 0000000..896addc --- /dev/null +++ b/src/gs-job.c.orig @@ -0,0 +1,567 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS) +#include +#endif + +#include +#include +#include +#include + +#include "gs-debug.h" +#include "gs-job.h" + +#include "subprocs.h" + +static void gs_job_class_init (GSJobClass *klass); +static void gs_job_init (GSJob *job); +static void gs_job_finalize (GObject *object); + +#define GS_JOB_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_JOB, GSJobPrivate)) + +typedef enum +{ + GS_JOB_INVALID, + GS_JOB_RUNNING, + GS_JOB_STOPPED, + GS_JOB_KILLED, + GS_JOB_DEAD +} GSJobStatus; + +struct GSJobPrivate +{ + GtkWidget *widget; + + GSJobStatus status; + gint pid; + guint watch_id; + + char *command; +}; + +G_DEFINE_TYPE (GSJob, gs_job, G_TYPE_OBJECT) + +static char * +widget_get_id_string (GtkWidget *widget) +{ + char *id = NULL; + + g_return_val_if_fail (widget != NULL, NULL); + + id = g_strdup_printf ("0x%X", + (guint32)GDK_WINDOW_XID (widget->window)); + return id; +} + +static void +gs_job_class_init (GSJobClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_job_finalize; + + g_type_class_add_private (klass, sizeof (GSJobPrivate)); +} + +static void +gs_job_init (GSJob *job) +{ + job->priv = GS_JOB_GET_PRIVATE (job); +} + +/* adapted from gspawn.c */ +static int +wait_on_child (int pid) +{ + int status; + +wait_again: + if (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + goto wait_again; + } + else if (errno == ECHILD) + { + ; /* do nothing, child already reaped */ + } + else + { + gs_debug ("waitpid () should not fail in 'GSJob'"); + } + } + + return status; +} + +static void +gs_job_died (GSJob *job) +{ + if (job->priv->pid > 0) + { + int exit_status; + + gs_debug ("Waiting on process %d", job->priv->pid); + exit_status = wait_on_child (job->priv->pid); + + job->priv->status = GS_JOB_DEAD; + + if (WIFEXITED (exit_status) && (WEXITSTATUS (exit_status) != 0)) + { + gs_debug ("Wait on child process failed"); + } + else + { + /* exited normally */ + } + } + g_spawn_close_pid (job->priv->pid); + job->priv->pid = 0; + + gs_debug ("Job died"); +} + +static void +gs_job_finalize (GObject *object) +{ + GSJob *job; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_JOB (object)); + + job = GS_JOB (object); + + g_return_if_fail (job->priv != NULL); + + if (job->priv->pid > 0) + { + signal_pid (job->priv->pid, SIGTERM); + gs_job_died (job); + } + + g_free (job->priv->command); + job->priv->command = NULL; + + G_OBJECT_CLASS (gs_job_parent_class)->finalize (object); +} + +void +gs_job_set_widget (GSJob *job, + GtkWidget *widget) +{ + g_return_if_fail (job != NULL); + g_return_if_fail (GS_IS_JOB (job)); + + if (widget != job->priv->widget) + { + job->priv->widget = widget; + + /* restart job */ + if (gs_job_is_running (job)) + { + gs_job_stop (job); + gs_job_start (job); + } + } +} + +gboolean +gs_job_set_command (GSJob *job, + const char *command) +{ + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("Setting command for job: '%s'", + command != NULL ? command : "NULL"); + + g_free (job->priv->command); + job->priv->command = g_strdup (command); + + return TRUE; +} + +GSJob * +gs_job_new (void) +{ + GObject *job; + + job = g_object_new (GS_TYPE_JOB, NULL); + + return GS_JOB (job); +} + +GSJob * +gs_job_new_for_widget (GtkWidget *widget) +{ + GObject *job; + + job = g_object_new (GS_TYPE_JOB, NULL); + + gs_job_set_widget (GS_JOB (job), widget); + + return GS_JOB (job); +} + +static void +nice_process (int pid, + int nice_level) +{ + g_return_if_fail (pid > 0); + + if (nice_level == 0) + { + return; + } + +#if defined(HAVE_SETPRIORITY) && defined(PRIO_PROCESS) + gs_debug ("Setting child process priority to: %d", nice_level); + if (setpriority (PRIO_PROCESS, pid, nice_level) != 0) + { + gs_debug ("setpriority(PRIO_PROCESS, %lu, %d) failed", + (unsigned long) pid, nice_level); + } +#else + gs_debug ("don't know how to change process priority on this system."); +#endif +} + +static GPtrArray * +get_env_vars (GtkWidget *widget) +{ + GPtrArray *env; + char *str; + int i; + static const char *allowed_env_vars [] = + { + "PATH", + "SESSION_MANAGER", + "XAUTHORITY", + "XAUTHLOCALHOSTNAME", + "LANG", + "LANGUAGE", + "DBUS_SESSION_BUS_ADDRESS" + }; + + env = g_ptr_array_new (); + + str = gdk_screen_make_display_name (gtk_widget_get_screen (widget)); + g_ptr_array_add (env, g_strdup_printf ("DISPLAY=%s", str)); + g_free (str); + + g_ptr_array_add (env, g_strdup_printf ("HOME=%s", + g_get_home_dir ())); + + for (i = 0; i < G_N_ELEMENTS (allowed_env_vars); i++) + { + const char *var; + const char *val; + var = allowed_env_vars [i]; + val = g_getenv (var); + if (val != NULL) + { + g_ptr_array_add (env, g_strdup_printf ("%s=%s", + var, + val)); + } + } + + str = widget_get_id_string (widget); + g_ptr_array_add (env, g_strdup_printf ("XSCREENSAVER_WINDOW=%s", str)); + g_free (str); + + g_ptr_array_add (env, NULL); + + return env; +} + +static gboolean +spawn_on_widget (GtkWidget *widget, + const char *command, + int *pid, + GIOFunc watch_func, + gpointer user_data, + guint *watch_id) +{ + char **argv; + GPtrArray *env; + gboolean result; + GIOChannel *channel; + GError *error = NULL; + int standard_error; + int child_pid; + int id; + int i; + + if (command == NULL) + { + return FALSE; + } + + if (! g_shell_parse_argv (command, NULL, &argv, &error)) + { + gs_debug ("Could not parse command: %s", error->message); + g_error_free (error); + return FALSE; + } + + env = get_env_vars (widget); + + error = NULL; + result = gdk_spawn_on_screen_with_pipes (gtk_widget_get_screen (widget), + NULL, + argv, + (char **)env->pdata, + G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, + NULL, + NULL, + &child_pid, + NULL, + NULL, + &standard_error, + &error); + for (i = 0; i < env->len; i++) + { + g_free (g_ptr_array_index (env, i)); + } + g_ptr_array_free (env, TRUE); + + if (! result) + { + gs_debug ("Could not start command '%s': %s", command, error->message); + g_error_free (error); + g_strfreev (argv); + return FALSE; + } + + g_strfreev (argv); + + nice_process (child_pid, 10); + + if (pid != NULL) + { + *pid = child_pid; + } + else + { + g_spawn_close_pid (child_pid); + } + + channel = g_io_channel_unix_new (standard_error); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + watch_func, + user_data); + if (watch_id != NULL) + { + *watch_id = id; + } + + g_io_channel_unref (channel); + + return result; +} + +static gboolean +command_watch (GIOChannel *source, + GIOCondition condition, + GSJob *job) +{ + GIOStatus status; + GError *error = NULL; + gboolean done = FALSE; + + g_return_val_if_fail (job != NULL, FALSE); + + if (condition & G_IO_IN) + { + char *str; + + status = g_io_channel_read_line (source, &str, NULL, NULL, &error); + + if (status == G_IO_STATUS_NORMAL) + { + gs_debug ("command output: %s", str); + + } + else if (status == G_IO_STATUS_EOF) + { + done = TRUE; + + } + else if (error != NULL) + { + gs_debug ("command error: %s", error->message); + g_error_free (error); + } + + g_free (str); + } + else if (condition & G_IO_HUP) + { + done = TRUE; + } + + if (done) + { + gs_job_died (job); + + job->priv->watch_id = 0; + return FALSE; + } + + return TRUE; +} + +gboolean +gs_job_is_running (GSJob *job) +{ + gboolean running; + + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + running = (job->priv->pid > 0); + + return running; +} + +gboolean +gs_job_start (GSJob *job) +{ + gboolean result; + + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("starting job"); + + if (job->priv->pid != 0) + { + gs_debug ("Cannot restart active job."); + return FALSE; + } + + if (job->priv->widget == NULL) + { + gs_debug ("Could not start job: screensaver window is not set."); + return FALSE; + } + + if (job->priv->command == NULL) + { + /* no warning here because a NULL command is interpreted + as a no-op job */ + gs_debug ("No command set for job."); + return FALSE; + } + + result = spawn_on_widget (job->priv->widget, + job->priv->command, + &job->priv->pid, + (GIOFunc)command_watch, + job, + &job->priv->watch_id); + + if (result) + { + job->priv->status = GS_JOB_RUNNING; + } + + return result; +} + +static void +remove_command_watch (GSJob *job) +{ + if (job->priv->watch_id != 0) + { + g_source_remove (job->priv->watch_id); + job->priv->watch_id = 0; + } +} + +gboolean +gs_job_stop (GSJob *job) +{ + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("stopping job"); + + if (job->priv->pid == 0) + { + gs_debug ("Could not stop job: pid not defined"); + return FALSE; + } + + if (job->priv->status == GS_JOB_STOPPED) + { + gs_job_suspend (job, FALSE); + } + + remove_command_watch (job); + + signal_pid (job->priv->pid, SIGTERM); + + job->priv->status = GS_JOB_KILLED; + + gs_job_died (job); + + return TRUE; +} + +gboolean +gs_job_suspend (GSJob *job, + gboolean suspend) +{ + g_return_val_if_fail (job != NULL, FALSE); + g_return_val_if_fail (GS_IS_JOB (job), FALSE); + + gs_debug ("suspending job"); + + if (job->priv->pid == 0) + { + return FALSE; + } + + signal_pid (job->priv->pid, (suspend ? SIGSTOP : SIGCONT)); + + job->priv->status = (suspend ? GS_JOB_STOPPED : GS_JOB_RUNNING); + + return TRUE; +} diff --git a/src/gs-job.h b/src/gs-job.h new file mode 100644 index 0000000..ba7084e --- /dev/null +++ b/src/gs-job.h @@ -0,0 +1,69 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_JOB_H +#define __GS_JOB_H + +#include + +G_BEGIN_DECLS + +#define GS_TYPE_JOB (gs_job_get_type ()) +#define GS_JOB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_JOB, GSJob)) +#define GS_JOB_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_JOB, GSJobClass)) +#define GS_IS_JOB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_JOB)) +#define GS_IS_JOB_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_JOB)) +#define GS_JOB_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_JOB, GSJobClass)) + +typedef struct GSJobPrivate GSJobPrivate; + +typedef struct +{ + GObject parent; + GSJobPrivate *priv; +} GSJob; + +typedef struct +{ + GObjectClass parent_class; +} GSJobClass; + +GType gs_job_get_type (void); + +GSJob *gs_job_new (void); +GSJob *gs_job_new_for_widget (GtkWidget *widget); + +gboolean gs_job_is_running (GSJob *job); +gboolean gs_job_start (GSJob *job); +gboolean gs_job_stop (GSJob *job); +gboolean gs_job_suspend (GSJob *job, + gboolean suspend); + +void gs_job_set_widget (GSJob *job, + GtkWidget *widget); + +gboolean gs_job_set_command (GSJob *job, + const char *command); + +G_END_DECLS + +#endif /* __GS_JOB_H */ diff --git a/src/gs-job.h.orig b/src/gs-job.h.orig new file mode 100644 index 0000000..b4fa3dc --- /dev/null +++ b/src/gs-job.h.orig @@ -0,0 +1,69 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_JOB_H +#define __GS_JOB_H + +#include + +G_BEGIN_DECLS + +#define GS_TYPE_JOB (gs_job_get_type ()) +#define GS_JOB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_JOB, GSJob)) +#define GS_JOB_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_JOB, GSJobClass)) +#define GS_IS_JOB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_JOB)) +#define GS_IS_JOB_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_JOB)) +#define GS_JOB_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_JOB, GSJobClass)) + +typedef struct GSJobPrivate GSJobPrivate; + +typedef struct +{ + GObject parent; + GSJobPrivate *priv; +} GSJob; + +typedef struct +{ + GObjectClass parent_class; +} GSJobClass; + +GType gs_job_get_type (void); + +GSJob *gs_job_new (void); +GSJob *gs_job_new_for_widget (GtkWidget *widget); + +gboolean gs_job_is_running (GSJob *job); +gboolean gs_job_start (GSJob *job); +gboolean gs_job_stop (GSJob *job); +gboolean gs_job_suspend (GSJob *job, + gboolean suspend); + +void gs_job_set_widget (GSJob *job, + GtkWidget *widget); + +gboolean gs_job_set_command (GSJob *job, + const char *command); + +G_END_DECLS + +#endif /* __GS_JOB_H */ diff --git a/src/gs-listener-dbus.c b/src/gs-listener-dbus.c new file mode 100644 index 0000000..601689c --- /dev/null +++ b/src/gs-listener-dbus.c @@ -0,0 +1,2272 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "gs-listener-dbus.h" +#include "gs-marshal.h" +#include "gs-debug.h" + +/* this is for dbus < 0.3 */ +#if ((DBUS_VERSION_MAJOR == 0) && (DBUS_VERSION_MINOR < 30)) +#define dbus_bus_name_has_owner(connection, name, err) dbus_bus_service_exists(connection, name, err) +#define dbus_bus_request_name(connection, name, flags, err) dbus_bus_acquire_service(connection, name, flags, err) +#endif + +static void gs_listener_class_init (GSListenerClass *klass); +static void gs_listener_init (GSListener *listener); +static void gs_listener_finalize (GObject *object); + +static void gs_listener_unregister_handler (DBusConnection *connection, + void *data); + +static DBusHandlerResult gs_listener_message_handler (DBusConnection *connection, + DBusMessage *message, + void *user_data); + +#define GS_LISTENER_SERVICE "org.mate.ScreenSaver" +#define GS_LISTENER_PATH "/org/mate/ScreenSaver" +#define GS_LISTENER_INTERFACE "org.mate.ScreenSaver" + +#define HAL_DEVICE_INTERFACE "org.freedesktop.Hal.Device" + +#define CK_NAME "org.freedesktop.ConsoleKit" +#define CK_MANAGER_PATH "/org/freedesktop/ConsoleKit/Manager" +#define CK_MANAGER_INTERFACE "org.freedesktop.ConsoleKit.Manager" +#define CK_SESSION_INTERFACE "org.freedesktop.ConsoleKit.Session" + +#define SESSION_NAME "org.mate.SessionManager" +#define SESSION_PATH "/org/mate/SessionManager" +#define SESSION_INTERFACE "org.mate.SessionManager" + +#define TYPE_MISMATCH_ERROR GS_LISTENER_INTERFACE ".TypeMismatch" + +#define GS_LISTENER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_LISTENER, GSListenerPrivate)) + +struct GSListenerPrivate +{ + DBusConnection *connection; + DBusConnection *system_connection; + + guint session_idle : 1; + guint active : 1; + guint activation_enabled : 1; + guint throttled : 1; + GHashTable *inhibitors; + GHashTable *throttlers; + time_t active_start; + time_t session_idle_start; + char *session_id; + + guint32 ck_throttle_cookie; +}; + +typedef struct +{ + int entry_type; + char *application; + char *reason; + char *connection; + guint32 cookie; + guint32 foreign_cookie; + GTimeVal since; +} GSListenerRefEntry; + +enum +{ + LOCK, + CYCLE, + QUIT, + SIMULATE_USER_ACTIVITY, + ACTIVE_CHANGED, + THROTTLE_CHANGED, + SHOW_MESSAGE, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_ACTIVE, + PROP_SESSION_IDLE, + PROP_ACTIVATION_ENABLED, +}; + +enum +{ + REF_ENTRY_TYPE_INHIBIT, + REF_ENTRY_TYPE_THROTTLE +}; + +static DBusObjectPathVTable +gs_listener_vtable = { &gs_listener_unregister_handler, + &gs_listener_message_handler, + NULL, + NULL, + NULL, + NULL + }; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSListener, gs_listener, G_TYPE_OBJECT) + +GQuark +gs_listener_error_quark (void) +{ + static GQuark quark = 0; + if (!quark) + { + quark = g_quark_from_static_string ("gs_listener_error"); + } + + return quark; +} + +static void +gs_listener_ref_entry_free (GSListenerRefEntry *entry) +{ + g_free (entry->connection); + g_free (entry->application); + g_free (entry->reason); + g_free (entry); + entry = NULL; +} + +static void +gs_listener_unregister_handler (DBusConnection *connection, + void *data) +{ +} + +static gboolean +send_dbus_message (DBusConnection *connection, + DBusMessage *message) +{ + gboolean is_connected; + gboolean sent; + + g_return_val_if_fail (message != NULL, FALSE); + + if (! connection) + { + gs_debug ("There is no valid connection to the message bus"); + return FALSE; + } + + is_connected = dbus_connection_get_is_connected (connection); + if (! is_connected) + { + gs_debug ("Not connected to the message bus"); + return FALSE; + } + + sent = dbus_connection_send (connection, message, NULL); + + return sent; +} + +static void +send_dbus_boolean_signal (GSListener *listener, + const char *name, + gboolean value) +{ + DBusMessage *message; + DBusMessageIter iter; + + g_return_if_fail (listener != NULL); + + message = dbus_message_new_signal (GS_LISTENER_PATH, + GS_LISTENER_SERVICE, + name); + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &value); + + if (! send_dbus_message (listener->priv->connection, message)) + { + gs_debug ("Could not send %s signal", name); + } + + dbus_message_unref (message); +} + +static void +gs_listener_send_signal_active_changed (GSListener *listener) +{ + g_return_if_fail (listener != NULL); + + gs_debug ("Sending the ActiveChanged(%s) signal on the session bus", + listener->priv->active ? "TRUE" : "FALSE"); + + send_dbus_boolean_signal (listener, "ActiveChanged", listener->priv->active); +} + +static const char * +get_name_for_entry_type (int entry_type) +{ + const char *name; + + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + name = "inhibitor"; + break; + case REF_ENTRY_TYPE_THROTTLE: + name = "throttler"; + break; + default: + g_assert_not_reached (); + break; + } + + return name; +} + +static GHashTable * +get_hash_for_entry_type (GSListener *listener, + int entry_type) +{ + GHashTable *hash; + + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + hash = listener->priv->inhibitors; + break; + case REF_ENTRY_TYPE_THROTTLE: + hash = listener->priv->throttlers; + break; + default: + g_assert_not_reached (); + break; + } + + return hash; +} + +static void +list_ref_entry (gpointer key, + gpointer value, + gpointer user_data) +{ + GSListenerRefEntry *entry; + + entry = (GSListenerRefEntry *)value; + + gs_debug ("%s: %s for reason: %s", + get_name_for_entry_type (entry->entry_type), + entry->application, + entry->reason); +} + +static gboolean +listener_ref_entry_is_present (GSListener *listener, + int entry_type) +{ + guint n_entries; + gboolean is_set; + GHashTable *hash; + + hash = get_hash_for_entry_type (listener, entry_type); + + /* if we aren't inhibited then activate */ + n_entries = 0; + if (hash != NULL) + { + n_entries = g_hash_table_size (hash); + + g_hash_table_foreach (hash, list_ref_entry, NULL); + } + + is_set = (n_entries > 0); + + return is_set; +} + +static gboolean +listener_check_activation (GSListener *listener) +{ + gboolean inhibited; + gboolean res; + + gs_debug ("Checking for activation"); + + if (! listener->priv->activation_enabled) + { + return TRUE; + } + + if (! listener->priv->session_idle) + { + return TRUE; + } + + /* if we aren't inhibited then activate */ + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + res = FALSE; + if (! inhibited) + { + gs_debug ("Trying to activate"); + res = gs_listener_set_active (listener, TRUE); + } + + return res; +} + +static void +gs_listener_set_throttle (GSListener *listener, + gboolean throttled) +{ + g_return_if_fail (GS_IS_LISTENER (listener)); + + if (listener->priv->throttled != throttled) + { + gs_debug ("Changing throttle status: %d", throttled); + + listener->priv->throttled = throttled; + + g_signal_emit (listener, signals [THROTTLE_CHANGED], 0, throttled); + } +} + +static gboolean +listener_check_throttle (GSListener *listener) +{ + gboolean throttled; + + gs_debug ("Checking for throttle"); + + throttled = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_THROTTLE); + + if (throttled != listener->priv->throttled) + { + gs_listener_set_throttle (listener, throttled); + } + + return TRUE; +} + +static gboolean +listener_set_session_idle_internal (GSListener *listener, + gboolean idle) +{ + listener->priv->session_idle = idle; + + if (idle) + { + listener->priv->session_idle_start = time (NULL); + } + else + { + listener->priv->session_idle_start = 0; + } + + return TRUE; +} + +static gboolean +listener_set_active_internal (GSListener *listener, + gboolean active) +{ + listener->priv->active = active; + + /* if idle not in sync with active, change it */ + if (listener->priv->session_idle != active) + { + listener_set_session_idle_internal (listener, active); + } + + if (active) + { + listener->priv->active_start = time (NULL); + } + else + { + listener->priv->active_start = 0; + } + + gs_listener_send_signal_active_changed (listener); + + return TRUE; +} + +gboolean +gs_listener_set_active (GSListener *listener, + gboolean active) +{ + gboolean res; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + if (listener->priv->active == active) + { + gs_debug ("Trying to set active state when already: %s", + active ? "active" : "inactive"); + return FALSE; + } + + res = FALSE; + g_signal_emit (listener, signals [ACTIVE_CHANGED], 0, active, &res); + if (! res) + { + /* if the signal is not handled then we haven't changed state */ + gs_debug ("Active-changed signal not handled"); + + /* clear the idle state */ + if (active) + { + listener_set_session_idle_internal (listener, FALSE); + } + + return FALSE; + } + + listener_set_active_internal (listener, active); + + return TRUE; +} + +gboolean +gs_listener_set_session_idle (GSListener *listener, + gboolean idle) +{ + gboolean res; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + gs_debug ("Setting session idle: %d", idle); + + if (listener->priv->session_idle == idle) + { + gs_debug ("Trying to set idle state when already %s", + idle ? "idle" : "not idle"); + return FALSE; + } + + if (idle) + { + gboolean inhibited; + + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + /* if we are inhibited then do nothing */ + if (inhibited) + { + return FALSE; + } + } + + listener->priv->session_idle = idle; + res = listener_check_activation (listener); + + /* if activation fails then don't set idle */ + if (res) + { + listener_set_session_idle_internal (listener, idle); + } + else + { + gs_debug ("Idle activation failed"); + listener->priv->session_idle = !idle; + } + + return res; +} + +gboolean +gs_listener_get_activation_enabled (GSListener *listener) +{ + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + return listener->priv->activation_enabled; +} + +gboolean +gs_listener_is_inhibited (GSListener *listener) +{ + gboolean inhibited; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + return inhibited; +} + +void +gs_listener_set_activation_enabled (GSListener *listener, + gboolean enabled) +{ + g_return_if_fail (GS_IS_LISTENER (listener)); + + if (listener->priv->activation_enabled != enabled) + { + listener->priv->activation_enabled = enabled; + } +} + +static dbus_bool_t +listener_property_set_bool (GSListener *listener, + guint prop_id, + dbus_bool_t value) +{ + dbus_bool_t ret; + + ret = FALSE; + + switch (prop_id) + { + case PROP_ACTIVE: + gs_listener_set_active (listener, value); + ret = TRUE; + break; + default: + break; + } + + return ret; +} + +static void +raise_error (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *error_name, + char *format, ...) +{ + char buf[512]; + DBusMessage *reply; + + va_list args; + va_start (args, format); + vsnprintf (buf, sizeof (buf), format, args); + va_end (args); + + gs_debug (buf); + reply = dbus_message_new_error (in_reply_to, error_name, buf); + if (reply == NULL) + { + g_error ("No memory"); + } + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); +} + +static void +raise_syntax (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *method_name) +{ + raise_error (connection, in_reply_to, + GS_LISTENER_SERVICE ".SyntaxError", + "There is a syntax error in the invocation of the method %s", + method_name); +} + +static guint32 +generate_cookie (void) +{ + guint32 cookie; + + cookie = (guint32)g_random_int_range (1, G_MAXINT32); + + return cookie; +} + +static guint32 +listener_generate_unique_key (GSListener *listener, + int entry_type) +{ + guint32 cookie; + GHashTable *hash; + + hash = get_hash_for_entry_type (listener, entry_type); + + do + { + cookie = generate_cookie (); + } + while (g_hash_table_lookup (hash, &cookie) != NULL); + + return cookie; +} + +static void +listener_ref_entry_check (GSListener *listener, + int entry_type) +{ + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + listener_check_activation (listener); + break; + case REF_ENTRY_TYPE_THROTTLE: + listener_check_throttle (listener); + break; + default: + g_assert_not_reached (); + break; + } +} + +static void +add_session_inhibit (GSListener *listener, + GSListenerRefEntry *entry) +{ + DBusMessage *message; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter reply_iter; + DBusError error; + guint xid; + guint flags; + + g_return_if_fail (listener != NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (SESSION_NAME, + SESSION_PATH, + SESSION_INTERFACE, + "Inhibit"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return; + } + + dbus_message_iter_init_append (message, &iter); + xid = 0; + flags = 8; + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &entry->application); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &xid); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &entry->reason); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &flags); + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->connection, + message, + -1, + &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return; + } + + dbus_message_iter_init (reply, &reply_iter); + dbus_message_iter_get_basic (&reply_iter, &entry->foreign_cookie); + + dbus_message_unref (reply); +} + +static void +remove_session_inhibit (GSListener *listener, + GSListenerRefEntry *entry) +{ + DBusMessage *message; + DBusMessage *reply; + DBusMessageIter iter; + DBusError error; + + g_return_if_fail (listener != NULL); + + if (entry->foreign_cookie == 0) + { + gs_debug ("Can't remove inhibitor from session: Session cookie not set"); + return; + } + + dbus_error_init (&error); + + message = dbus_message_new_method_call (SESSION_NAME, + SESSION_PATH, + SESSION_INTERFACE, + "Uninhibit"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &entry->foreign_cookie); + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->connection, + message, + -1, + &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return; + } + + dbus_message_unref (reply); +} + +static void +listener_add_ref_entry (GSListener *listener, + int entry_type, + GSListenerRefEntry *entry) +{ + GHashTable *hash; + + gs_debug ("adding %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry_type), + entry->application, + entry->reason, + entry->connection); + + hash = get_hash_for_entry_type (listener, entry_type); + g_hash_table_insert (hash, &entry->cookie, entry); + + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* proxy inhibit over to mate session */ + add_session_inhibit (listener, entry); + } + + listener_ref_entry_check (listener, entry_type); +} + +static gboolean +listener_remove_ref_entry (GSListener *listener, + int entry_type, + guint32 cookie) +{ + GHashTable *hash; + gboolean removed; + GSListenerRefEntry *entry; + + removed = FALSE; + + hash = get_hash_for_entry_type (listener, entry_type); + + entry = g_hash_table_lookup (hash, &cookie); + if (entry == NULL) + { + goto out; + } + + gs_debug ("removing %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry_type), + entry->application, + entry->reason, + entry->connection); + + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* remove inhibit from mate session */ + remove_session_inhibit (listener, entry); + } + + removed = g_hash_table_remove (hash, &cookie); +out: + if (removed) + { + listener_ref_entry_check (listener, entry_type); + } + else + { + gs_debug ("Cookie %u was not in the list!", cookie); + } + + return removed; +} + +#if GLIB_CHECK_VERSION(2,12,0) +#define _g_time_val_to_iso8601(t) g_time_val_to_iso8601(t) +#else +/* copied from GLib */ +static gchar * +_g_time_val_to_iso8601 (GTimeVal *time_) +{ + gchar *retval; + + g_return_val_if_fail (time_->tv_usec >= 0 && time_->tv_usec < G_USEC_PER_SEC, NULL); + +#define ISO_8601_LEN 21 +#define ISO_8601_FORMAT "%Y-%m-%dT%H:%M:%SZ" + retval = g_new0 (gchar, ISO_8601_LEN + 1); + + strftime (retval, ISO_8601_LEN, + ISO_8601_FORMAT, + gmtime (&(time_->tv_sec))); + + return retval; +} +#endif + +static void +accumulate_ref_entry (gpointer key, + GSListenerRefEntry *entry, + DBusMessageIter *iter) +{ + char *description; + char *time; + + time = _g_time_val_to_iso8601 (&entry->since); + + description = g_strdup_printf ("Application=\"%s\"; Since=\"%s\"; Reason=\"%s\";", + entry->application, + time, + entry->reason); + + dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &description); + + g_free (description); + g_free (time); +} + +static DBusHandlerResult +listener_dbus_get_ref_entries (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + GHashTable *hash; + DBusMessageIter iter; + DBusMessageIter iter_array; + + hash = get_hash_for_entry_type (listener, entry_type); + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + { + g_error ("No memory"); + } + + dbus_message_iter_init_append (reply, &iter); + dbus_message_iter_open_container (&iter, + DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, + &iter_array); + + if (hash != NULL) + { + g_hash_table_foreach (hash, + (GHFunc)accumulate_ref_entry, + &iter_array); + } + + dbus_message_iter_close_container (&iter, &iter_array); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static void +listener_add_ck_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message, + guint32 *cookiep) +{ + GSListenerRefEntry *entry; + + entry = g_new0 (GSListenerRefEntry, 1); + entry->entry_type = entry_type; + entry->connection = g_strdup (dbus_message_get_sender (message)); + entry->cookie = listener_generate_unique_key (listener, entry_type); + entry->application = g_strdup ("ConsoleKit"); + entry->reason = g_strdup ("Session is not active"); + g_get_current_time (&entry->since); + + /* takes ownership of entry */ + listener_add_ref_entry (listener, entry_type, entry); + + if (cookiep != NULL) + { + *cookiep = entry->cookie; + } +} + +static void +listener_remove_ck_ref_entry (GSListener *listener, + int entry_type, + guint32 cookie) +{ + listener_remove_ref_entry (listener, entry_type, cookie); +} + +static DBusHandlerResult +listener_dbus_add_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + DBusError error; + const char *application; + const char *reason; + GSListenerRefEntry *entry; + DBusMessageIter iter; + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &application, + DBUS_TYPE_STRING, &reason, + DBUS_TYPE_INVALID)) + { + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + raise_syntax (connection, message, "Inhibit"); + } + else if (entry_type == REF_ENTRY_TYPE_THROTTLE) + { + raise_syntax (connection, message, "Throttle"); + } + else + { + g_assert_not_reached (); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + { + g_error ("No memory"); + } + + entry = g_new0 (GSListenerRefEntry, 1); + entry->entry_type = entry_type; + entry->connection = g_strdup (dbus_message_get_sender (message)); + entry->cookie = listener_generate_unique_key (listener, entry_type); + entry->application = g_strdup (application); + entry->reason = g_strdup (reason); + g_get_current_time (&entry->since); + + listener_add_ref_entry (listener, entry_type, entry); + + dbus_message_iter_init_append (reply, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &entry->cookie); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_remove_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + DBusError error; + const char *sender; + guint32 cookie; + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_UINT32, &cookie, + DBUS_TYPE_INVALID)) + { + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + raise_syntax (connection, message, "UnInhibit"); + } + else if (entry_type == REF_ENTRY_TYPE_THROTTLE) + { + raise_syntax (connection, message, "UnThrottle"); + } + else + { + g_assert_not_reached (); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + g_error ("No memory"); + + /* FIXME: check sender is from same connection as entry */ + sender = dbus_message_get_sender (message); + + listener_remove_ref_entry (listener, entry_type, cookie); + + /* FIXME: Pointless? */ + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static gboolean +listener_ref_entry_remove_for_connection (GSListener *listener, + int entry_type, + const char *connection) +{ + gboolean removed; + GHashTable *hash; + GHashTableIter iter; + GSListenerRefEntry *entry; + + if (connection == NULL) + return FALSE; + + hash = get_hash_for_entry_type (listener, entry_type); + + removed = FALSE; + g_hash_table_iter_init (&iter, hash); + while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&entry)) + { + if (entry->connection != NULL && + strcmp (connection, entry->connection) == 0) + { + gs_debug ("removing %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry->entry_type), + entry->application, + entry->reason, + entry->connection); + + if (entry->entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* remove inhibit from mate session */ + remove_session_inhibit (listener, entry); + } + + g_hash_table_iter_remove (&iter); + removed = TRUE; + } + } + + return removed; +} + +static void +listener_service_deleted (GSListener *listener, + DBusMessage *message) +{ + const char *old_service_name; + const char *new_service_name; + gboolean removed; + + if (! dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &old_service_name, + DBUS_TYPE_STRING, &new_service_name, + DBUS_TYPE_INVALID)) + { + g_error ("Invalid NameOwnerChanged signal from bus!"); + return; + } + + gs_debug ("DBUS service deleted: %s", new_service_name); + + removed = listener_ref_entry_remove_for_connection (listener, REF_ENTRY_TYPE_THROTTLE, new_service_name); + if (removed) + { + listener_ref_entry_check (listener, REF_ENTRY_TYPE_THROTTLE); + } + + removed = listener_ref_entry_remove_for_connection (listener, REF_ENTRY_TYPE_INHIBIT, new_service_name); + if (removed) + { + listener_ref_entry_check (listener, REF_ENTRY_TYPE_INHIBIT); + } + +} + +static void +raise_property_type_error (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *device_id) +{ + char buf [512]; + DBusMessage *reply; + + snprintf (buf, 511, + "Type mismatch setting property with id %s", + device_id); + gs_debug (buf); + + reply = dbus_message_new_error (in_reply_to, + TYPE_MISMATCH_ERROR, + buf); + if (reply == NULL) + { + g_error ("No memory"); + } + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); +} + +static DBusHandlerResult +listener_set_property (GSListener *listener, + DBusConnection *connection, + DBusMessage *message, + guint prop_id) +{ + const char *path; + int type; + gboolean rc; + DBusMessageIter iter; + DBusMessage *reply; + + path = dbus_message_get_path (message); + + dbus_message_iter_init (message, &iter); + type = dbus_message_iter_get_arg_type (&iter); + rc = FALSE; + + switch (type) + { + case DBUS_TYPE_BOOLEAN: + { + dbus_bool_t v; + dbus_message_iter_get_basic (&iter, &v); + rc = listener_property_set_bool (listener, prop_id, v); + break; + } + default: + gs_debug ("Unsupported property type %d", type); + break; + } + + if (! rc) + { + raise_property_type_error (connection, message, path); + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_get_property (GSListener *listener, + DBusConnection *connection, + DBusMessage *message, + guint prop_id) +{ + DBusMessageIter iter; + DBusMessage *reply; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + g_error ("No memory"); + + switch (prop_id) + { + case PROP_ACTIVE: + { + dbus_bool_t b; + b = listener->priv->active; + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &b); + } + break; + default: + gs_debug ("Unsupported property id %u", prop_id); + break; + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_get_active_time (GSListener *listener, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessageIter iter; + DBusMessage *reply; + dbus_uint32_t secs; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (listener->priv->active) + { + time_t now = time (NULL); + + if (now < listener->priv->active_start) + { + /* shouldn't happen */ + gs_debug ("Active start time is in the future"); + secs = 0; + } + else if (listener->priv->active_start <= 0) + { + /* shouldn't happen */ + gs_debug ("Active start time was not set"); + secs = 0; + } + else + { + secs = now - listener->priv->active_start; + } + } + else + { + secs = 0; + } + + gs_debug ("Returning screensaver active for %u seconds", secs); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &secs); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_show_message (GSListener *listener, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessageIter iter; + DBusMessage *reply; + DBusError error; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (listener->priv->active) + { + char *summary; + char *body; + char *icon; + + /* if we're not active we ignore the request */ + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &summary, + DBUS_TYPE_STRING, &body, + DBUS_TYPE_STRING, &icon, + DBUS_TYPE_INVALID)) + { + raise_syntax (connection, message, "ShowMessage"); + return DBUS_HANDLER_RESULT_HANDLED; + } + + g_signal_emit (listener, signals [SHOW_MESSAGE], 0, summary, body, icon); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +do_introspect (DBusConnection *connection, + DBusMessage *message, + dbus_bool_t local_interface) +{ + DBusMessage *reply; + GString *xml; + char *xml_string; + + /* standard header */ + xml = g_string_new ("\n" + "\n" + " \n" + " \n" + " \n" + " \n" + " \n"); + + /* ScreenSaver interface */ + xml = g_string_append (xml, + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n"); + + reply = dbus_message_new_method_return (message); + + xml = g_string_append (xml, "\n"); + xml_string = g_string_free (xml, FALSE); + + dbus_message_append_args (reply, + DBUS_TYPE_STRING, &xml_string, + DBUS_TYPE_INVALID); + + g_free (xml_string); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_handle_session_message (DBusConnection *connection, + DBusMessage *message, + void *user_data, + dbus_bool_t local_interface) +{ + GSListener *listener = GS_LISTENER (user_data); + +#if 0 + g_message ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Lock")) + { + g_signal_emit (listener, signals [LOCK], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Quit")) + { + g_signal_emit (listener, signals [QUIT], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Cycle")) + { + g_signal_emit (listener, signals [CYCLE], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Inhibit")) + { + return listener_dbus_add_ref_entry (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "UnInhibit")) + { + return listener_dbus_remove_ref_entry (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetInhibitors")) + { + return listener_dbus_get_ref_entries (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Throttle")) + { + return listener_dbus_add_ref_entry (listener, REF_ENTRY_TYPE_THROTTLE, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "UnThrottle")) + { + return listener_dbus_remove_ref_entry (listener, REF_ENTRY_TYPE_THROTTLE, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "SetActive")) + { + return listener_set_property (listener, connection, message, PROP_ACTIVE); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetActive")) + { + return listener_get_property (listener, connection, message, PROP_ACTIVE); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetActiveTime")) + { + return listener_get_active_time (listener, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "ShowMessage")) + { + return listener_show_message (listener, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "SimulateUserActivity")) + { + g_signal_emit (listener, signals [SIMULATE_USER_ACTIVITY], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) + { + return do_introspect (connection, message, local_interface); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static gboolean +_listener_message_path_is_our_session (GSListener *listener, + DBusMessage *message) +{ + const char *ssid; + gboolean ours; + + ours = FALSE; + + ssid = dbus_message_get_path (message); + if (ssid != NULL + && listener->priv->session_id != NULL + && strcmp (ssid, listener->priv->session_id) == 0) + { + ours = TRUE; + } + + return ours; +} + +static DBusHandlerResult +listener_dbus_handle_system_message (DBusConnection *connection, + DBusMessage *message, + void *user_data, + dbus_bool_t local_interface) +{ + GSListener *listener = GS_LISTENER (user_data); + + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + +#if 1 + gs_debug ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + if (dbus_message_is_signal (message, HAL_DEVICE_INTERFACE, "Condition")) + { + DBusError error; + const char *event; + const char *keyname; + + dbus_error_init (&error); + if (dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &event, + DBUS_TYPE_STRING, &keyname, + DBUS_TYPE_INVALID)) + { + if ((event && strcmp (event, "ButtonPressed") == 0) && + (keyname && strcmp (keyname, "coffee") == 0)) + { + gs_debug ("Coffee key was pressed - locking"); + g_signal_emit (listener, signals [LOCK], 0); + } + } + + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "Unlock")) + { + if (_listener_message_path_is_our_session (listener, message)) + { + gs_debug ("Console kit requested session unlock"); + gs_listener_set_active (listener, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "Lock")) + { + if (_listener_message_path_is_our_session (listener, message)) + { + gs_debug ("ConsoleKit requested session lock"); + g_signal_emit (listener, signals [LOCK], 0); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "ActiveChanged")) + { + /* NB that `ActiveChanged' refers to the active + * session in ConsoleKit terminology - ie which + * session is currently displayed on the screen. + * mate-screensaver uses `active' to mean `is the + * screensaver active' (ie, is the screen locked) but + * that's not what we're referring to here. + */ + + if (_listener_message_path_is_our_session (listener, message)) + { + DBusError error; + dbus_bool_t new_active; + + dbus_error_init (&error); + if (dbus_message_get_args (message, &error, + DBUS_TYPE_BOOLEAN, &new_active, + DBUS_TYPE_INVALID)) + { + gs_debug ("ConsoleKit notified ActiveChanged %d", new_active); + + /* when we aren't active add an implicit throttle from CK + * when we become active remove the throttle and poke the lock */ + if (new_active) + { + if (listener->priv->ck_throttle_cookie != 0) + { + listener_remove_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + listener->priv->ck_throttle_cookie); + listener->priv->ck_throttle_cookie = 0; + } + + g_signal_emit (listener, signals [SIMULATE_USER_ACTIVITY], 0); + } + else + { + if (listener->priv->ck_throttle_cookie != 0) + { + g_warning ("ConsoleKit throttle already set"); + listener_remove_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + listener->priv->ck_throttle_cookie); + listener->priv->ck_throttle_cookie = 0; + } + + listener_add_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + connection, + message, + &listener->priv->ck_throttle_cookie); + } + } + + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static DBusHandlerResult +gs_listener_message_handler (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + +#if 0 + g_message ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + if (dbus_message_is_method_call (message, "org.freedesktop.DBus", "AddMatch")) + { + DBusMessage *reply; + + reply = dbus_message_new_method_return (message); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") && + strcmp (dbus_message_get_path (message), DBUS_PATH_LOCAL) == 0) + { + dbus_connection_unref (connection); + + return DBUS_HANDLER_RESULT_HANDLED; + } + else + { + return listener_dbus_handle_session_message (connection, message, user_data, TRUE); + } +} + +static gboolean +gs_listener_dbus_init (GSListener *listener) +{ + DBusError error; + + dbus_error_init (&error); + + if (listener->priv->connection == NULL) + { + listener->priv->connection = dbus_bus_get (DBUS_BUS_SESSION, &error); + if (listener->priv->connection == NULL) + { + if (dbus_error_is_set (&error)) + { + gs_debug ("couldn't connect to session bus: %s", + error.message); + dbus_error_free (&error); + } + return FALSE; + } + + dbus_connection_setup_with_g_main (listener->priv->connection, NULL); + dbus_connection_set_exit_on_disconnect (listener->priv->connection, FALSE); + } + + if (listener->priv->system_connection == NULL) + { + listener->priv->system_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error); + if (listener->priv->system_connection == NULL) + { + if (dbus_error_is_set (&error)) + { + gs_debug ("couldn't connect to system bus: %s", + error.message); + dbus_error_free (&error); + } + return FALSE; + } + + dbus_connection_setup_with_g_main (listener->priv->system_connection, NULL); + dbus_connection_set_exit_on_disconnect (listener->priv->system_connection, FALSE); + } + + return TRUE; +} + +static gboolean +reinit_dbus (GSListener *listener) +{ + gboolean initialized; + gboolean try_again; + + initialized = gs_listener_dbus_init (listener); + + /* if we didn't initialize then try again */ + /* FIXME: Should we keep trying forever? If we fail more than + once or twice then the session bus may have died. The + problem is that if it is restarted it will likely have a + different bus address and we won't be able to find it */ + try_again = !initialized; + + return try_again; +} + +static DBusHandlerResult +listener_dbus_filter_function (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + GSListener *listener = GS_LISTENER (user_data); + const char *path; + + path = dbus_message_get_path (message); + + /* + g_message ("obj_path=%s interface=%s method=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message)); + */ + + if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") + && strcmp (path, DBUS_PATH_LOCAL) == 0) + { + + g_message ("Got disconnected from the session message bus; " + "retrying to reconnect every 10 seconds"); + + dbus_connection_unref (connection); + listener->priv->connection = NULL; + + g_timeout_add (10000, (GSourceFunc)reinit_dbus, listener); + } + else if (dbus_message_is_signal (message, + DBUS_INTERFACE_DBUS, + "NameOwnerChanged")) + { + + if (listener->priv->inhibitors != NULL) + { + listener_service_deleted (listener, message); + } + } + else + { + return listener_dbus_handle_session_message (connection, message, user_data, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_system_filter_function (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + GSListener *listener = GS_LISTENER (user_data); + const char *path; + + path = dbus_message_get_path (message); + + if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") + && strcmp (path, DBUS_PATH_LOCAL) == 0) + { + + g_message ("Got disconnected from the system message bus; " + "retrying to reconnect every 10 seconds"); + + dbus_connection_unref (connection); + listener->priv->system_connection = NULL; + + g_timeout_add (10000, (GSourceFunc)reinit_dbus, listener); + } + else + { + return listener_dbus_handle_system_message (connection, message, user_data, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static void +gs_listener_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSListener *self; + + self = GS_LISTENER (object); + + switch (prop_id) + { + case PROP_ACTIVE: + gs_listener_set_active (self, g_value_get_boolean (value)); + break; + case PROP_SESSION_IDLE: + gs_listener_set_session_idle (self, g_value_get_boolean (value)); + break; + case PROP_ACTIVATION_ENABLED: + gs_listener_set_activation_enabled (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_listener_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSListener *self; + + self = GS_LISTENER (object); + + switch (prop_id) + { + case PROP_ACTIVE: + g_value_set_boolean (value, self->priv->active); + break; + case PROP_SESSION_IDLE: + g_value_set_boolean (value, self->priv->session_idle); + break; + case PROP_ACTIVATION_ENABLED: + g_value_set_boolean (value, self->priv->activation_enabled); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_listener_class_init (GSListenerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_listener_finalize; + object_class->get_property = gs_listener_get_property; + object_class->set_property = gs_listener_set_property; + + signals [LOCK] = + g_signal_new ("lock", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, lock), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [QUIT] = + g_signal_new ("quit", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, quit), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [CYCLE] = + g_signal_new ("cycle", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, cycle), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [SIMULATE_USER_ACTIVITY] = + g_signal_new ("simulate-user-activity", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, simulate_user_activity), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [ACTIVE_CHANGED] = + g_signal_new ("active-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, active_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, + G_TYPE_BOOLEAN); + signals [THROTTLE_CHANGED] = + g_signal_new ("throttle-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, throttle_changed), + NULL, + NULL, + g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, + 1, + G_TYPE_BOOLEAN); + signals [SHOW_MESSAGE] = + g_signal_new ("show-message", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, show_message), + NULL, + NULL, + gs_marshal_VOID__STRING_STRING_STRING, + G_TYPE_NONE, + 3, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING); + + g_object_class_install_property (object_class, + PROP_ACTIVE, + g_param_spec_boolean ("active", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_ACTIVATION_ENABLED, + g_param_spec_boolean ("activation-enabled", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_type_class_add_private (klass, sizeof (GSListenerPrivate)); +} + + +static gboolean +screensaver_is_running (DBusConnection *connection) +{ + DBusError error; + gboolean exists; + + g_return_val_if_fail (connection != NULL, FALSE); + + dbus_error_init (&error); + exists = dbus_bus_name_has_owner (connection, GS_LISTENER_SERVICE, &error); + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + + return exists; +} + +gboolean +gs_listener_acquire (GSListener *listener, + GError **error) +{ + gboolean acquired; + DBusError buserror; + gboolean is_connected; + + g_return_val_if_fail (listener != NULL, FALSE); + + if (! listener->priv->connection) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("failed to register with the message bus")); + return FALSE; + } + + is_connected = dbus_connection_get_is_connected (listener->priv->connection); + if (! is_connected) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("not connected to the message bus")); + return FALSE; + } + + if (screensaver_is_running (listener->priv->connection)) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("screensaver already running in this session")); + return FALSE; + } + + dbus_error_init (&buserror); + + if (dbus_connection_register_object_path (listener->priv->connection, + GS_LISTENER_PATH, + &gs_listener_vtable, + listener) == FALSE) + { + g_critical ("out of memory registering object path"); + return FALSE; + } + + acquired = dbus_bus_request_name (listener->priv->connection, + GS_LISTENER_SERVICE, + 0, &buserror) != -1; + if (dbus_error_is_set (&buserror)) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + buserror.message); + } + + dbus_error_free (&buserror); + + dbus_connection_add_filter (listener->priv->connection, listener_dbus_filter_function, listener, NULL); + + dbus_bus_add_match (listener->priv->connection, + "type='signal'" + ",interface='"DBUS_INTERFACE_DBUS"'" + ",sender='"DBUS_SERVICE_DBUS"'" + ",member='NameOwnerChanged'", + NULL); + + if (listener->priv->system_connection != NULL) + { + dbus_connection_add_filter (listener->priv->system_connection, + listener_dbus_system_filter_function, + listener, + NULL); + + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"HAL_DEVICE_INTERFACE"'" + ",member='Condition'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='Unlock'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='Lock'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='ActiveChanged'", + NULL); + } + + return acquired; +} + +static char * +query_session_id (GSListener *listener) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter reply_iter; + char *ssid; + + if (listener->priv->system_connection == NULL) + { + gs_debug ("No connection to the system bus"); + return NULL; + } + + ssid = NULL; + + dbus_error_init (&error); + + message = dbus_message_new_method_call (CK_NAME, CK_MANAGER_PATH, CK_MANAGER_INTERFACE, "GetCurrentSession"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return NULL; + } + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->system_connection, + message, + -1, &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return NULL; + } + + dbus_message_iter_init (reply, &reply_iter); + dbus_message_iter_get_basic (&reply_iter, &ssid); + + dbus_message_unref (reply); + + return g_strdup (ssid); +} + +static void +init_session_id (GSListener *listener) +{ + g_free (listener->priv->session_id); + listener->priv->session_id = query_session_id (listener); + gs_debug ("Got session-id: %s", listener->priv->session_id); +} + +static void +gs_listener_init (GSListener *listener) +{ + listener->priv = GS_LISTENER_GET_PRIVATE (listener); + + gs_listener_dbus_init (listener); + + init_session_id (listener); + + listener->priv->inhibitors = g_hash_table_new_full (g_int_hash, + g_int_equal, + NULL, + (GDestroyNotify)gs_listener_ref_entry_free); + listener->priv->throttlers = g_hash_table_new_full (g_int_hash, + g_int_equal, + NULL, + (GDestroyNotify)gs_listener_ref_entry_free); +} + +static void +gs_listener_finalize (GObject *object) +{ + GSListener *listener; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_LISTENER (object)); + + listener = GS_LISTENER (object); + + g_return_if_fail (listener->priv != NULL); + + if (listener->priv->inhibitors) + { + g_hash_table_destroy (listener->priv->inhibitors); + } + + if (listener->priv->throttlers) + { + g_hash_table_destroy (listener->priv->throttlers); + } + + g_free (listener->priv->session_id); + + G_OBJECT_CLASS (gs_listener_parent_class)->finalize (object); +} + +GSListener * +gs_listener_new (void) +{ + GSListener *listener; + + listener = g_object_new (GS_TYPE_LISTENER, NULL); + + return GS_LISTENER (listener); +} diff --git a/src/gs-listener-dbus.c.orig b/src/gs-listener-dbus.c.orig new file mode 100644 index 0000000..b8d4fab --- /dev/null +++ b/src/gs-listener-dbus.c.orig @@ -0,0 +1,2272 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "gs-listener-dbus.h" +#include "gs-marshal.h" +#include "gs-debug.h" + +/* this is for dbus < 0.3 */ +#if ((DBUS_VERSION_MAJOR == 0) && (DBUS_VERSION_MINOR < 30)) +#define dbus_bus_name_has_owner(connection, name, err) dbus_bus_service_exists(connection, name, err) +#define dbus_bus_request_name(connection, name, flags, err) dbus_bus_acquire_service(connection, name, flags, err) +#endif + +static void gs_listener_class_init (GSListenerClass *klass); +static void gs_listener_init (GSListener *listener); +static void gs_listener_finalize (GObject *object); + +static void gs_listener_unregister_handler (DBusConnection *connection, + void *data); + +static DBusHandlerResult gs_listener_message_handler (DBusConnection *connection, + DBusMessage *message, + void *user_data); + +#define GS_LISTENER_SERVICE "org.mate.ScreenSaver" +#define GS_LISTENER_PATH "/org/mate/ScreenSaver" +#define GS_LISTENER_INTERFACE "org.mate.ScreenSaver" + +#define HAL_DEVICE_INTERFACE "org.freedesktop.Hal.Device" + +#define CK_NAME "org.freedesktop.ConsoleKit" +#define CK_MANAGER_PATH "/org/freedesktop/ConsoleKit/Manager" +#define CK_MANAGER_INTERFACE "org.freedesktop.ConsoleKit.Manager" +#define CK_SESSION_INTERFACE "org.freedesktop.ConsoleKit.Session" + +#define SESSION_NAME "org.mate.SessionManager" +#define SESSION_PATH "/org/mate/SessionManager" +#define SESSION_INTERFACE "org.mate.SessionManager" + +#define TYPE_MISMATCH_ERROR GS_LISTENER_INTERFACE ".TypeMismatch" + +#define GS_LISTENER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_LISTENER, GSListenerPrivate)) + +struct GSListenerPrivate +{ + DBusConnection *connection; + DBusConnection *system_connection; + + guint session_idle : 1; + guint active : 1; + guint activation_enabled : 1; + guint throttled : 1; + GHashTable *inhibitors; + GHashTable *throttlers; + time_t active_start; + time_t session_idle_start; + char *session_id; + + guint32 ck_throttle_cookie; +}; + +typedef struct +{ + int entry_type; + char *application; + char *reason; + char *connection; + guint32 cookie; + guint32 foreign_cookie; + GTimeVal since; +} GSListenerRefEntry; + +enum +{ + LOCK, + CYCLE, + QUIT, + SIMULATE_USER_ACTIVITY, + ACTIVE_CHANGED, + THROTTLE_CHANGED, + SHOW_MESSAGE, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_ACTIVE, + PROP_SESSION_IDLE, + PROP_ACTIVATION_ENABLED, +}; + +enum +{ + REF_ENTRY_TYPE_INHIBIT, + REF_ENTRY_TYPE_THROTTLE +}; + +static DBusObjectPathVTable +gs_listener_vtable = { &gs_listener_unregister_handler, + &gs_listener_message_handler, + NULL, + NULL, + NULL, + NULL + }; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSListener, gs_listener, G_TYPE_OBJECT) + +GQuark +gs_listener_error_quark (void) +{ + static GQuark quark = 0; + if (!quark) + { + quark = g_quark_from_static_string ("gs_listener_error"); + } + + return quark; +} + +static void +gs_listener_ref_entry_free (GSListenerRefEntry *entry) +{ + g_free (entry->connection); + g_free (entry->application); + g_free (entry->reason); + g_free (entry); + entry = NULL; +} + +static void +gs_listener_unregister_handler (DBusConnection *connection, + void *data) +{ +} + +static gboolean +send_dbus_message (DBusConnection *connection, + DBusMessage *message) +{ + gboolean is_connected; + gboolean sent; + + g_return_val_if_fail (message != NULL, FALSE); + + if (! connection) + { + gs_debug ("There is no valid connection to the message bus"); + return FALSE; + } + + is_connected = dbus_connection_get_is_connected (connection); + if (! is_connected) + { + gs_debug ("Not connected to the message bus"); + return FALSE; + } + + sent = dbus_connection_send (connection, message, NULL); + + return sent; +} + +static void +send_dbus_boolean_signal (GSListener *listener, + const char *name, + gboolean value) +{ + DBusMessage *message; + DBusMessageIter iter; + + g_return_if_fail (listener != NULL); + + message = dbus_message_new_signal (GS_LISTENER_PATH, + GS_LISTENER_SERVICE, + name); + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &value); + + if (! send_dbus_message (listener->priv->connection, message)) + { + gs_debug ("Could not send %s signal", name); + } + + dbus_message_unref (message); +} + +static void +gs_listener_send_signal_active_changed (GSListener *listener) +{ + g_return_if_fail (listener != NULL); + + gs_debug ("Sending the ActiveChanged(%s) signal on the session bus", + listener->priv->active ? "TRUE" : "FALSE"); + + send_dbus_boolean_signal (listener, "ActiveChanged", listener->priv->active); +} + +static const char * +get_name_for_entry_type (int entry_type) +{ + const char *name; + + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + name = "inhibitor"; + break; + case REF_ENTRY_TYPE_THROTTLE: + name = "throttler"; + break; + default: + g_assert_not_reached (); + break; + } + + return name; +} + +static GHashTable * +get_hash_for_entry_type (GSListener *listener, + int entry_type) +{ + GHashTable *hash; + + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + hash = listener->priv->inhibitors; + break; + case REF_ENTRY_TYPE_THROTTLE: + hash = listener->priv->throttlers; + break; + default: + g_assert_not_reached (); + break; + } + + return hash; +} + +static void +list_ref_entry (gpointer key, + gpointer value, + gpointer user_data) +{ + GSListenerRefEntry *entry; + + entry = (GSListenerRefEntry *)value; + + gs_debug ("%s: %s for reason: %s", + get_name_for_entry_type (entry->entry_type), + entry->application, + entry->reason); +} + +static gboolean +listener_ref_entry_is_present (GSListener *listener, + int entry_type) +{ + guint n_entries; + gboolean is_set; + GHashTable *hash; + + hash = get_hash_for_entry_type (listener, entry_type); + + /* if we aren't inhibited then activate */ + n_entries = 0; + if (hash != NULL) + { + n_entries = g_hash_table_size (hash); + + g_hash_table_foreach (hash, list_ref_entry, NULL); + } + + is_set = (n_entries > 0); + + return is_set; +} + +static gboolean +listener_check_activation (GSListener *listener) +{ + gboolean inhibited; + gboolean res; + + gs_debug ("Checking for activation"); + + if (! listener->priv->activation_enabled) + { + return TRUE; + } + + if (! listener->priv->session_idle) + { + return TRUE; + } + + /* if we aren't inhibited then activate */ + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + res = FALSE; + if (! inhibited) + { + gs_debug ("Trying to activate"); + res = gs_listener_set_active (listener, TRUE); + } + + return res; +} + +static void +gs_listener_set_throttle (GSListener *listener, + gboolean throttled) +{ + g_return_if_fail (GS_IS_LISTENER (listener)); + + if (listener->priv->throttled != throttled) + { + gs_debug ("Changing throttle status: %d", throttled); + + listener->priv->throttled = throttled; + + g_signal_emit (listener, signals [THROTTLE_CHANGED], 0, throttled); + } +} + +static gboolean +listener_check_throttle (GSListener *listener) +{ + gboolean throttled; + + gs_debug ("Checking for throttle"); + + throttled = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_THROTTLE); + + if (throttled != listener->priv->throttled) + { + gs_listener_set_throttle (listener, throttled); + } + + return TRUE; +} + +static gboolean +listener_set_session_idle_internal (GSListener *listener, + gboolean idle) +{ + listener->priv->session_idle = idle; + + if (idle) + { + listener->priv->session_idle_start = time (NULL); + } + else + { + listener->priv->session_idle_start = 0; + } + + return TRUE; +} + +static gboolean +listener_set_active_internal (GSListener *listener, + gboolean active) +{ + listener->priv->active = active; + + /* if idle not in sync with active, change it */ + if (listener->priv->session_idle != active) + { + listener_set_session_idle_internal (listener, active); + } + + if (active) + { + listener->priv->active_start = time (NULL); + } + else + { + listener->priv->active_start = 0; + } + + gs_listener_send_signal_active_changed (listener); + + return TRUE; +} + +gboolean +gs_listener_set_active (GSListener *listener, + gboolean active) +{ + gboolean res; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + if (listener->priv->active == active) + { + gs_debug ("Trying to set active state when already: %s", + active ? "active" : "inactive"); + return FALSE; + } + + res = FALSE; + g_signal_emit (listener, signals [ACTIVE_CHANGED], 0, active, &res); + if (! res) + { + /* if the signal is not handled then we haven't changed state */ + gs_debug ("Active-changed signal not handled"); + + /* clear the idle state */ + if (active) + { + listener_set_session_idle_internal (listener, FALSE); + } + + return FALSE; + } + + listener_set_active_internal (listener, active); + + return TRUE; +} + +gboolean +gs_listener_set_session_idle (GSListener *listener, + gboolean idle) +{ + gboolean res; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + gs_debug ("Setting session idle: %d", idle); + + if (listener->priv->session_idle == idle) + { + gs_debug ("Trying to set idle state when already %s", + idle ? "idle" : "not idle"); + return FALSE; + } + + if (idle) + { + gboolean inhibited; + + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + /* if we are inhibited then do nothing */ + if (inhibited) + { + return FALSE; + } + } + + listener->priv->session_idle = idle; + res = listener_check_activation (listener); + + /* if activation fails then don't set idle */ + if (res) + { + listener_set_session_idle_internal (listener, idle); + } + else + { + gs_debug ("Idle activation failed"); + listener->priv->session_idle = !idle; + } + + return res; +} + +gboolean +gs_listener_get_activation_enabled (GSListener *listener) +{ + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + return listener->priv->activation_enabled; +} + +gboolean +gs_listener_is_inhibited (GSListener *listener) +{ + gboolean inhibited; + + g_return_val_if_fail (GS_IS_LISTENER (listener), FALSE); + + inhibited = listener_ref_entry_is_present (listener, REF_ENTRY_TYPE_INHIBIT); + + return inhibited; +} + +void +gs_listener_set_activation_enabled (GSListener *listener, + gboolean enabled) +{ + g_return_if_fail (GS_IS_LISTENER (listener)); + + if (listener->priv->activation_enabled != enabled) + { + listener->priv->activation_enabled = enabled; + } +} + +static dbus_bool_t +listener_property_set_bool (GSListener *listener, + guint prop_id, + dbus_bool_t value) +{ + dbus_bool_t ret; + + ret = FALSE; + + switch (prop_id) + { + case PROP_ACTIVE: + gs_listener_set_active (listener, value); + ret = TRUE; + break; + default: + break; + } + + return ret; +} + +static void +raise_error (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *error_name, + char *format, ...) +{ + char buf[512]; + DBusMessage *reply; + + va_list args; + va_start (args, format); + vsnprintf (buf, sizeof (buf), format, args); + va_end (args); + + gs_debug (buf); + reply = dbus_message_new_error (in_reply_to, error_name, buf); + if (reply == NULL) + { + g_error ("No memory"); + } + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); +} + +static void +raise_syntax (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *method_name) +{ + raise_error (connection, in_reply_to, + GS_LISTENER_SERVICE ".SyntaxError", + "There is a syntax error in the invocation of the method %s", + method_name); +} + +static guint32 +generate_cookie (void) +{ + guint32 cookie; + + cookie = (guint32)g_random_int_range (1, G_MAXINT32); + + return cookie; +} + +static guint32 +listener_generate_unique_key (GSListener *listener, + int entry_type) +{ + guint32 cookie; + GHashTable *hash; + + hash = get_hash_for_entry_type (listener, entry_type); + + do + { + cookie = generate_cookie (); + } + while (g_hash_table_lookup (hash, &cookie) != NULL); + + return cookie; +} + +static void +listener_ref_entry_check (GSListener *listener, + int entry_type) +{ + switch (entry_type) + { + case REF_ENTRY_TYPE_INHIBIT: + listener_check_activation (listener); + break; + case REF_ENTRY_TYPE_THROTTLE: + listener_check_throttle (listener); + break; + default: + g_assert_not_reached (); + break; + } +} + +static void +add_session_inhibit (GSListener *listener, + GSListenerRefEntry *entry) +{ + DBusMessage *message; + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter reply_iter; + DBusError error; + guint xid; + guint flags; + + g_return_if_fail (listener != NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (SESSION_NAME, + SESSION_PATH, + SESSION_INTERFACE, + "Inhibit"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return; + } + + dbus_message_iter_init_append (message, &iter); + xid = 0; + flags = 8; + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &entry->application); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &xid); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &entry->reason); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &flags); + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->connection, + message, + -1, + &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return; + } + + dbus_message_iter_init (reply, &reply_iter); + dbus_message_iter_get_basic (&reply_iter, &entry->foreign_cookie); + + dbus_message_unref (reply); +} + +static void +remove_session_inhibit (GSListener *listener, + GSListenerRefEntry *entry) +{ + DBusMessage *message; + DBusMessage *reply; + DBusMessageIter iter; + DBusError error; + + g_return_if_fail (listener != NULL); + + if (entry->foreign_cookie == 0) + { + gs_debug ("Can't remove inhibitor from session: Session cookie not set"); + return; + } + + dbus_error_init (&error); + + message = dbus_message_new_method_call (SESSION_NAME, + SESSION_PATH, + SESSION_INTERFACE, + "Uninhibit"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &entry->foreign_cookie); + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->connection, + message, + -1, + &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return; + } + + dbus_message_unref (reply); +} + +static void +listener_add_ref_entry (GSListener *listener, + int entry_type, + GSListenerRefEntry *entry) +{ + GHashTable *hash; + + gs_debug ("adding %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry_type), + entry->application, + entry->reason, + entry->connection); + + hash = get_hash_for_entry_type (listener, entry_type); + g_hash_table_insert (hash, &entry->cookie, entry); + + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* proxy inhibit over to mate session */ + add_session_inhibit (listener, entry); + } + + listener_ref_entry_check (listener, entry_type); +} + +static gboolean +listener_remove_ref_entry (GSListener *listener, + int entry_type, + guint32 cookie) +{ + GHashTable *hash; + gboolean removed; + GSListenerRefEntry *entry; + + removed = FALSE; + + hash = get_hash_for_entry_type (listener, entry_type); + + entry = g_hash_table_lookup (hash, &cookie); + if (entry == NULL) + { + goto out; + } + + gs_debug ("removing %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry_type), + entry->application, + entry->reason, + entry->connection); + + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* remove inhibit from mate session */ + remove_session_inhibit (listener, entry); + } + + removed = g_hash_table_remove (hash, &cookie); +out: + if (removed) + { + listener_ref_entry_check (listener, entry_type); + } + else + { + gs_debug ("Cookie %u was not in the list!", cookie); + } + + return removed; +} + +#if GLIB_CHECK_VERSION(2,12,0) +#define _g_time_val_to_iso8601(t) g_time_val_to_iso8601(t) +#else +/* copied from GLib */ +static gchar * +_g_time_val_to_iso8601 (GTimeVal *time_) +{ + gchar *retval; + + g_return_val_if_fail (time_->tv_usec >= 0 && time_->tv_usec < G_USEC_PER_SEC, NULL); + +#define ISO_8601_LEN 21 +#define ISO_8601_FORMAT "%Y-%m-%dT%H:%M:%SZ" + retval = g_new0 (gchar, ISO_8601_LEN + 1); + + strftime (retval, ISO_8601_LEN, + ISO_8601_FORMAT, + gmtime (&(time_->tv_sec))); + + return retval; +} +#endif + +static void +accumulate_ref_entry (gpointer key, + GSListenerRefEntry *entry, + DBusMessageIter *iter) +{ + char *description; + char *time; + + time = _g_time_val_to_iso8601 (&entry->since); + + description = g_strdup_printf ("Application=\"%s\"; Since=\"%s\"; Reason=\"%s\";", + entry->application, + time, + entry->reason); + + dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &description); + + g_free (description); + g_free (time); +} + +static DBusHandlerResult +listener_dbus_get_ref_entries (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + GHashTable *hash; + DBusMessageIter iter; + DBusMessageIter iter_array; + + hash = get_hash_for_entry_type (listener, entry_type); + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + { + g_error ("No memory"); + } + + dbus_message_iter_init_append (reply, &iter); + dbus_message_iter_open_container (&iter, + DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, + &iter_array); + + if (hash != NULL) + { + g_hash_table_foreach (hash, + (GHFunc)accumulate_ref_entry, + &iter_array); + } + + dbus_message_iter_close_container (&iter, &iter_array); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static void +listener_add_ck_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message, + guint32 *cookiep) +{ + GSListenerRefEntry *entry; + + entry = g_new0 (GSListenerRefEntry, 1); + entry->entry_type = entry_type; + entry->connection = g_strdup (dbus_message_get_sender (message)); + entry->cookie = listener_generate_unique_key (listener, entry_type); + entry->application = g_strdup ("ConsoleKit"); + entry->reason = g_strdup ("Session is not active"); + g_get_current_time (&entry->since); + + /* takes ownership of entry */ + listener_add_ref_entry (listener, entry_type, entry); + + if (cookiep != NULL) + { + *cookiep = entry->cookie; + } +} + +static void +listener_remove_ck_ref_entry (GSListener *listener, + int entry_type, + guint32 cookie) +{ + listener_remove_ref_entry (listener, entry_type, cookie); +} + +static DBusHandlerResult +listener_dbus_add_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + DBusError error; + const char *application; + const char *reason; + GSListenerRefEntry *entry; + DBusMessageIter iter; + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &application, + DBUS_TYPE_STRING, &reason, + DBUS_TYPE_INVALID)) + { + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + raise_syntax (connection, message, "Inhibit"); + } + else if (entry_type == REF_ENTRY_TYPE_THROTTLE) + { + raise_syntax (connection, message, "Throttle"); + } + else + { + g_assert_not_reached (); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + { + g_error ("No memory"); + } + + entry = g_new0 (GSListenerRefEntry, 1); + entry->entry_type = entry_type; + entry->connection = g_strdup (dbus_message_get_sender (message)); + entry->cookie = listener_generate_unique_key (listener, entry_type); + entry->application = g_strdup (application); + entry->reason = g_strdup (reason); + g_get_current_time (&entry->since); + + listener_add_ref_entry (listener, entry_type, entry); + + dbus_message_iter_init_append (reply, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &entry->cookie); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_remove_ref_entry (GSListener *listener, + int entry_type, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessage *reply; + DBusError error; + const char *sender; + guint32 cookie; + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_UINT32, &cookie, + DBUS_TYPE_INVALID)) + { + if (entry_type == REF_ENTRY_TYPE_INHIBIT) + { + raise_syntax (connection, message, "UnInhibit"); + } + else if (entry_type == REF_ENTRY_TYPE_THROTTLE) + { + raise_syntax (connection, message, "UnThrottle"); + } + else + { + g_assert_not_reached (); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + if (reply == NULL) + g_error ("No memory"); + + /* FIXME: check sender is from same connection as entry */ + sender = dbus_message_get_sender (message); + + listener_remove_ref_entry (listener, entry_type, cookie); + + /* FIXME: Pointless? */ + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static gboolean +listener_ref_entry_remove_for_connection (GSListener *listener, + int entry_type, + const char *connection) +{ + gboolean removed; + GHashTable *hash; + GHashTableIter iter; + GSListenerRefEntry *entry; + + if (connection == NULL) + return FALSE; + + hash = get_hash_for_entry_type (listener, entry_type); + + removed = FALSE; + g_hash_table_iter_init (&iter, hash); + while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&entry)) + { + if (entry->connection != NULL && + strcmp (connection, entry->connection) == 0) + { + gs_debug ("removing %s from %s for reason '%s' on connection %s", + get_name_for_entry_type (entry->entry_type), + entry->application, + entry->reason, + entry->connection); + + if (entry->entry_type == REF_ENTRY_TYPE_INHIBIT) + { + /* remove inhibit from mate session */ + remove_session_inhibit (listener, entry); + } + + g_hash_table_iter_remove (&iter); + removed = TRUE; + } + } + + return removed; +} + +static void +listener_service_deleted (GSListener *listener, + DBusMessage *message) +{ + const char *old_service_name; + const char *new_service_name; + gboolean removed; + + if (! dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &old_service_name, + DBUS_TYPE_STRING, &new_service_name, + DBUS_TYPE_INVALID)) + { + g_error ("Invalid NameOwnerChanged signal from bus!"); + return; + } + + gs_debug ("DBUS service deleted: %s", new_service_name); + + removed = listener_ref_entry_remove_for_connection (listener, REF_ENTRY_TYPE_THROTTLE, new_service_name); + if (removed) + { + listener_ref_entry_check (listener, REF_ENTRY_TYPE_THROTTLE); + } + + removed = listener_ref_entry_remove_for_connection (listener, REF_ENTRY_TYPE_INHIBIT, new_service_name); + if (removed) + { + listener_ref_entry_check (listener, REF_ENTRY_TYPE_INHIBIT); + } + +} + +static void +raise_property_type_error (DBusConnection *connection, + DBusMessage *in_reply_to, + const char *device_id) +{ + char buf [512]; + DBusMessage *reply; + + snprintf (buf, 511, + "Type mismatch setting property with id %s", + device_id); + gs_debug (buf); + + reply = dbus_message_new_error (in_reply_to, + TYPE_MISMATCH_ERROR, + buf); + if (reply == NULL) + { + g_error ("No memory"); + } + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); +} + +static DBusHandlerResult +listener_set_property (GSListener *listener, + DBusConnection *connection, + DBusMessage *message, + guint prop_id) +{ + const char *path; + int type; + gboolean rc; + DBusMessageIter iter; + DBusMessage *reply; + + path = dbus_message_get_path (message); + + dbus_message_iter_init (message, &iter); + type = dbus_message_iter_get_arg_type (&iter); + rc = FALSE; + + switch (type) + { + case DBUS_TYPE_BOOLEAN: + { + dbus_bool_t v; + dbus_message_iter_get_basic (&iter, &v); + rc = listener_property_set_bool (listener, prop_id, v); + break; + } + default: + gs_debug ("Unsupported property type %d", type); + break; + } + + if (! rc) + { + raise_property_type_error (connection, message, path); + return DBUS_HANDLER_RESULT_HANDLED; + } + + reply = dbus_message_new_method_return (message); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_get_property (GSListener *listener, + DBusConnection *connection, + DBusMessage *message, + guint prop_id) +{ + DBusMessageIter iter; + DBusMessage *reply; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + g_error ("No memory"); + + switch (prop_id) + { + case PROP_ACTIVE: + { + dbus_bool_t b; + b = listener->priv->active; + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &b); + } + break; + default: + gs_debug ("Unsupported property id %u", prop_id); + break; + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_get_active_time (GSListener *listener, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessageIter iter; + DBusMessage *reply; + dbus_uint32_t secs; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (listener->priv->active) + { + time_t now = time (NULL); + + if (now < listener->priv->active_start) + { + /* shouldn't happen */ + gs_debug ("Active start time is in the future"); + secs = 0; + } + else if (listener->priv->active_start <= 0) + { + /* shouldn't happen */ + gs_debug ("Active start time was not set"); + secs = 0; + } + else + { + secs = now - listener->priv->active_start; + } + } + else + { + secs = 0; + } + + gs_debug ("Returning screensaver active for %u seconds", secs); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_UINT32, &secs); + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_show_message (GSListener *listener, + DBusConnection *connection, + DBusMessage *message) +{ + DBusMessageIter iter; + DBusMessage *reply; + DBusError error; + + reply = dbus_message_new_method_return (message); + + dbus_message_iter_init_append (reply, &iter); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (listener->priv->active) + { + char *summary; + char *body; + char *icon; + + /* if we're not active we ignore the request */ + + dbus_error_init (&error); + if (! dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &summary, + DBUS_TYPE_STRING, &body, + DBUS_TYPE_STRING, &icon, + DBUS_TYPE_INVALID)) + { + raise_syntax (connection, message, "ShowMessage"); + return DBUS_HANDLER_RESULT_HANDLED; + } + + g_signal_emit (listener, signals [SHOW_MESSAGE], 0, summary, body, icon); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +do_introspect (DBusConnection *connection, + DBusMessage *message, + dbus_bool_t local_interface) +{ + DBusMessage *reply; + GString *xml; + char *xml_string; + + /* standard header */ + xml = g_string_new ("\n" + "\n" + " \n" + " \n" + " \n" + " \n" + " \n"); + + /* ScreenSaver interface */ + xml = g_string_append (xml, + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n" + " \n"); + + reply = dbus_message_new_method_return (message); + + xml = g_string_append (xml, "\n"); + xml_string = g_string_free (xml, FALSE); + + dbus_message_append_args (reply, + DBUS_TYPE_STRING, &xml_string, + DBUS_TYPE_INVALID); + + g_free (xml_string); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_handle_session_message (DBusConnection *connection, + DBusMessage *message, + void *user_data, + dbus_bool_t local_interface) +{ + GSListener *listener = GS_LISTENER (user_data); + +#if 0 + g_message ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Lock")) + { + g_signal_emit (listener, signals [LOCK], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Quit")) + { + g_signal_emit (listener, signals [QUIT], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Cycle")) + { + g_signal_emit (listener, signals [CYCLE], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Inhibit")) + { + return listener_dbus_add_ref_entry (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "UnInhibit")) + { + return listener_dbus_remove_ref_entry (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetInhibitors")) + { + return listener_dbus_get_ref_entries (listener, REF_ENTRY_TYPE_INHIBIT, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "Throttle")) + { + return listener_dbus_add_ref_entry (listener, REF_ENTRY_TYPE_THROTTLE, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "UnThrottle")) + { + return listener_dbus_remove_ref_entry (listener, REF_ENTRY_TYPE_THROTTLE, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "SetActive")) + { + return listener_set_property (listener, connection, message, PROP_ACTIVE); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetActive")) + { + return listener_get_property (listener, connection, message, PROP_ACTIVE); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "GetActiveTime")) + { + return listener_get_active_time (listener, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "ShowMessage")) + { + return listener_show_message (listener, connection, message); + } + if (dbus_message_is_method_call (message, GS_LISTENER_SERVICE, "SimulateUserActivity")) + { + g_signal_emit (listener, signals [SIMULATE_USER_ACTIVITY], 0); + return DBUS_HANDLER_RESULT_HANDLED; + } + if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) + { + return do_introspect (connection, message, local_interface); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static gboolean +_listener_message_path_is_our_session (GSListener *listener, + DBusMessage *message) +{ + const char *ssid; + gboolean ours; + + ours = FALSE; + + ssid = dbus_message_get_path (message); + if (ssid != NULL + && listener->priv->session_id != NULL + && strcmp (ssid, listener->priv->session_id) == 0) + { + ours = TRUE; + } + + return ours; +} + +static DBusHandlerResult +listener_dbus_handle_system_message (DBusConnection *connection, + DBusMessage *message, + void *user_data, + dbus_bool_t local_interface) +{ + GSListener *listener = GS_LISTENER (user_data); + + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + +#if 1 + gs_debug ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + if (dbus_message_is_signal (message, HAL_DEVICE_INTERFACE, "Condition")) + { + DBusError error; + const char *event; + const char *keyname; + + dbus_error_init (&error); + if (dbus_message_get_args (message, &error, + DBUS_TYPE_STRING, &event, + DBUS_TYPE_STRING, &keyname, + DBUS_TYPE_INVALID)) + { + if ((event && strcmp (event, "ButtonPressed") == 0) && + (keyname && strcmp (keyname, "coffee") == 0)) + { + gs_debug ("Coffee key was pressed - locking"); + g_signal_emit (listener, signals [LOCK], 0); + } + } + + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "Unlock")) + { + if (_listener_message_path_is_our_session (listener, message)) + { + gs_debug ("Console kit requested session unlock"); + gs_listener_set_active (listener, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "Lock")) + { + if (_listener_message_path_is_our_session (listener, message)) + { + gs_debug ("ConsoleKit requested session lock"); + g_signal_emit (listener, signals [LOCK], 0); + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, CK_SESSION_INTERFACE, "ActiveChanged")) + { + /* NB that `ActiveChanged' refers to the active + * session in ConsoleKit terminology - ie which + * session is currently displayed on the screen. + * mate-screensaver uses `active' to mean `is the + * screensaver active' (ie, is the screen locked) but + * that's not what we're referring to here. + */ + + if (_listener_message_path_is_our_session (listener, message)) + { + DBusError error; + dbus_bool_t new_active; + + dbus_error_init (&error); + if (dbus_message_get_args (message, &error, + DBUS_TYPE_BOOLEAN, &new_active, + DBUS_TYPE_INVALID)) + { + gs_debug ("ConsoleKit notified ActiveChanged %d", new_active); + + /* when we aren't active add an implicit throttle from CK + * when we become active remove the throttle and poke the lock */ + if (new_active) + { + if (listener->priv->ck_throttle_cookie != 0) + { + listener_remove_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + listener->priv->ck_throttle_cookie); + listener->priv->ck_throttle_cookie = 0; + } + + g_signal_emit (listener, signals [SIMULATE_USER_ACTIVITY], 0); + } + else + { + if (listener->priv->ck_throttle_cookie != 0) + { + g_warning ("ConsoleKit throttle already set"); + listener_remove_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + listener->priv->ck_throttle_cookie); + listener->priv->ck_throttle_cookie = 0; + } + + listener_add_ck_ref_entry (listener, + REF_ENTRY_TYPE_THROTTLE, + connection, + message, + &listener->priv->ck_throttle_cookie); + } + } + + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + } + + return DBUS_HANDLER_RESULT_HANDLED; + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static DBusHandlerResult +gs_listener_message_handler (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + +#if 0 + g_message ("obj_path=%s interface=%s method=%s destination=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message), + dbus_message_get_destination (message)); +#endif + + if (dbus_message_is_method_call (message, "org.freedesktop.DBus", "AddMatch")) + { + DBusMessage *reply; + + reply = dbus_message_new_method_return (message); + + if (reply == NULL) + { + g_error ("No memory"); + } + + if (! dbus_connection_send (connection, reply, NULL)) + { + g_error ("No memory"); + } + + dbus_message_unref (reply); + + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") && + strcmp (dbus_message_get_path (message), DBUS_PATH_LOCAL) == 0) + { + dbus_connection_unref (connection); + + return DBUS_HANDLER_RESULT_HANDLED; + } + else + { + return listener_dbus_handle_session_message (connection, message, user_data, TRUE); + } +} + +static gboolean +gs_listener_dbus_init (GSListener *listener) +{ + DBusError error; + + dbus_error_init (&error); + + if (listener->priv->connection == NULL) + { + listener->priv->connection = dbus_bus_get (DBUS_BUS_SESSION, &error); + if (listener->priv->connection == NULL) + { + if (dbus_error_is_set (&error)) + { + gs_debug ("couldn't connect to session bus: %s", + error.message); + dbus_error_free (&error); + } + return FALSE; + } + + dbus_connection_setup_with_g_main (listener->priv->connection, NULL); + dbus_connection_set_exit_on_disconnect (listener->priv->connection, FALSE); + } + + if (listener->priv->system_connection == NULL) + { + listener->priv->system_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error); + if (listener->priv->system_connection == NULL) + { + if (dbus_error_is_set (&error)) + { + gs_debug ("couldn't connect to system bus: %s", + error.message); + dbus_error_free (&error); + } + return FALSE; + } + + dbus_connection_setup_with_g_main (listener->priv->system_connection, NULL); + dbus_connection_set_exit_on_disconnect (listener->priv->system_connection, FALSE); + } + + return TRUE; +} + +static gboolean +reinit_dbus (GSListener *listener) +{ + gboolean initialized; + gboolean try_again; + + initialized = gs_listener_dbus_init (listener); + + /* if we didn't initialize then try again */ + /* FIXME: Should we keep trying forever? If we fail more than + once or twice then the session bus may have died. The + problem is that if it is restarted it will likely have a + different bus address and we won't be able to find it */ + try_again = !initialized; + + return try_again; +} + +static DBusHandlerResult +listener_dbus_filter_function (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + GSListener *listener = GS_LISTENER (user_data); + const char *path; + + path = dbus_message_get_path (message); + + /* + g_message ("obj_path=%s interface=%s method=%s", + dbus_message_get_path (message), + dbus_message_get_interface (message), + dbus_message_get_member (message)); + */ + + if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") + && strcmp (path, DBUS_PATH_LOCAL) == 0) + { + + g_message ("Got disconnected from the session message bus; " + "retrying to reconnect every 10 seconds"); + + dbus_connection_unref (connection); + listener->priv->connection = NULL; + + g_timeout_add (10000, (GSourceFunc)reinit_dbus, listener); + } + else if (dbus_message_is_signal (message, + DBUS_INTERFACE_DBUS, + "NameOwnerChanged")) + { + + if (listener->priv->inhibitors != NULL) + { + listener_service_deleted (listener, message); + } + } + else + { + return listener_dbus_handle_session_message (connection, message, user_data, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static DBusHandlerResult +listener_dbus_system_filter_function (DBusConnection *connection, + DBusMessage *message, + void *user_data) +{ + GSListener *listener = GS_LISTENER (user_data); + const char *path; + + path = dbus_message_get_path (message); + + if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") + && strcmp (path, DBUS_PATH_LOCAL) == 0) + { + + g_message ("Got disconnected from the system message bus; " + "retrying to reconnect every 10 seconds"); + + dbus_connection_unref (connection); + listener->priv->system_connection = NULL; + + g_timeout_add (10000, (GSourceFunc)reinit_dbus, listener); + } + else + { + return listener_dbus_handle_system_message (connection, message, user_data, FALSE); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static void +gs_listener_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSListener *self; + + self = GS_LISTENER (object); + + switch (prop_id) + { + case PROP_ACTIVE: + gs_listener_set_active (self, g_value_get_boolean (value)); + break; + case PROP_SESSION_IDLE: + gs_listener_set_session_idle (self, g_value_get_boolean (value)); + break; + case PROP_ACTIVATION_ENABLED: + gs_listener_set_activation_enabled (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_listener_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSListener *self; + + self = GS_LISTENER (object); + + switch (prop_id) + { + case PROP_ACTIVE: + g_value_set_boolean (value, self->priv->active); + break; + case PROP_SESSION_IDLE: + g_value_set_boolean (value, self->priv->session_idle); + break; + case PROP_ACTIVATION_ENABLED: + g_value_set_boolean (value, self->priv->activation_enabled); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_listener_class_init (GSListenerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_listener_finalize; + object_class->get_property = gs_listener_get_property; + object_class->set_property = gs_listener_set_property; + + signals [LOCK] = + g_signal_new ("lock", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, lock), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [QUIT] = + g_signal_new ("quit", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, quit), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [CYCLE] = + g_signal_new ("cycle", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, cycle), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [SIMULATE_USER_ACTIVITY] = + g_signal_new ("simulate-user-activity", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, simulate_user_activity), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [ACTIVE_CHANGED] = + g_signal_new ("active-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, active_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, + G_TYPE_BOOLEAN); + signals [THROTTLE_CHANGED] = + g_signal_new ("throttle-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, throttle_changed), + NULL, + NULL, + g_cclosure_marshal_VOID__BOOLEAN, + G_TYPE_NONE, + 1, + G_TYPE_BOOLEAN); + signals [SHOW_MESSAGE] = + g_signal_new ("show-message", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSListenerClass, show_message), + NULL, + NULL, + gs_marshal_VOID__STRING_STRING_STRING, + G_TYPE_NONE, + 3, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING); + + g_object_class_install_property (object_class, + PROP_ACTIVE, + g_param_spec_boolean ("active", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_ACTIVATION_ENABLED, + g_param_spec_boolean ("activation-enabled", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_type_class_add_private (klass, sizeof (GSListenerPrivate)); +} + + +static gboolean +screensaver_is_running (DBusConnection *connection) +{ + DBusError error; + gboolean exists; + + g_return_val_if_fail (connection != NULL, FALSE); + + dbus_error_init (&error); + exists = dbus_bus_name_has_owner (connection, GS_LISTENER_SERVICE, &error); + if (dbus_error_is_set (&error)) + { + dbus_error_free (&error); + } + + return exists; +} + +gboolean +gs_listener_acquire (GSListener *listener, + GError **error) +{ + gboolean acquired; + DBusError buserror; + gboolean is_connected; + + g_return_val_if_fail (listener != NULL, FALSE); + + if (! listener->priv->connection) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("failed to register with the message bus")); + return FALSE; + } + + is_connected = dbus_connection_get_is_connected (listener->priv->connection); + if (! is_connected) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("not connected to the message bus")); + return FALSE; + } + + if (screensaver_is_running (listener->priv->connection)) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + _("screensaver already running in this session")); + return FALSE; + } + + dbus_error_init (&buserror); + + if (dbus_connection_register_object_path (listener->priv->connection, + GS_LISTENER_PATH, + &gs_listener_vtable, + listener) == FALSE) + { + g_critical ("out of memory registering object path"); + return FALSE; + } + + acquired = dbus_bus_request_name (listener->priv->connection, + GS_LISTENER_SERVICE, + 0, &buserror) != -1; + if (dbus_error_is_set (&buserror)) + { + g_set_error (error, + GS_LISTENER_ERROR, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + "%s", + buserror.message); + } + + dbus_error_free (&buserror); + + dbus_connection_add_filter (listener->priv->connection, listener_dbus_filter_function, listener, NULL); + + dbus_bus_add_match (listener->priv->connection, + "type='signal'" + ",interface='"DBUS_INTERFACE_DBUS"'" + ",sender='"DBUS_SERVICE_DBUS"'" + ",member='NameOwnerChanged'", + NULL); + + if (listener->priv->system_connection != NULL) + { + dbus_connection_add_filter (listener->priv->system_connection, + listener_dbus_system_filter_function, + listener, + NULL); + + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"HAL_DEVICE_INTERFACE"'" + ",member='Condition'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='Unlock'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='Lock'", + NULL); + dbus_bus_add_match (listener->priv->system_connection, + "type='signal'" + ",interface='"CK_SESSION_INTERFACE"'" + ",member='ActiveChanged'", + NULL); + } + + return acquired; +} + +static char * +query_session_id (GSListener *listener) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter reply_iter; + char *ssid; + + if (listener->priv->system_connection == NULL) + { + gs_debug ("No connection to the system bus"); + return NULL; + } + + ssid = NULL; + + dbus_error_init (&error); + + message = dbus_message_new_method_call (CK_NAME, CK_MANAGER_PATH, CK_MANAGER_INTERFACE, "GetCurrentSession"); + if (message == NULL) + { + gs_debug ("Couldn't allocate the dbus message"); + return NULL; + } + + /* FIXME: use async? */ + reply = dbus_connection_send_with_reply_and_block (listener->priv->system_connection, + message, + -1, &error); + dbus_message_unref (message); + + if (dbus_error_is_set (&error)) + { + gs_debug ("%s raised:\n %s\n\n", error.name, error.message); + dbus_error_free (&error); + return NULL; + } + + dbus_message_iter_init (reply, &reply_iter); + dbus_message_iter_get_basic (&reply_iter, &ssid); + + dbus_message_unref (reply); + + return g_strdup (ssid); +} + +static void +init_session_id (GSListener *listener) +{ + g_free (listener->priv->session_id); + listener->priv->session_id = query_session_id (listener); + gs_debug ("Got session-id: %s", listener->priv->session_id); +} + +static void +gs_listener_init (GSListener *listener) +{ + listener->priv = GS_LISTENER_GET_PRIVATE (listener); + + gs_listener_dbus_init (listener); + + init_session_id (listener); + + listener->priv->inhibitors = g_hash_table_new_full (g_int_hash, + g_int_equal, + NULL, + (GDestroyNotify)gs_listener_ref_entry_free); + listener->priv->throttlers = g_hash_table_new_full (g_int_hash, + g_int_equal, + NULL, + (GDestroyNotify)gs_listener_ref_entry_free); +} + +static void +gs_listener_finalize (GObject *object) +{ + GSListener *listener; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_LISTENER (object)); + + listener = GS_LISTENER (object); + + g_return_if_fail (listener->priv != NULL); + + if (listener->priv->inhibitors) + { + g_hash_table_destroy (listener->priv->inhibitors); + } + + if (listener->priv->throttlers) + { + g_hash_table_destroy (listener->priv->throttlers); + } + + g_free (listener->priv->session_id); + + G_OBJECT_CLASS (gs_listener_parent_class)->finalize (object); +} + +GSListener * +gs_listener_new (void) +{ + GSListener *listener; + + listener = g_object_new (GS_TYPE_LISTENER, NULL); + + return GS_LISTENER (listener); +} diff --git a/src/gs-listener-dbus.h b/src/gs-listener-dbus.h new file mode 100644 index 0000000..a2e298a --- /dev/null +++ b/src/gs-listener-dbus.h @@ -0,0 +1,89 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_LISTENER_H +#define __GS_LISTENER_H + +G_BEGIN_DECLS + +#define GS_TYPE_LISTENER (gs_listener_get_type ()) +#define GS_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_LISTENER, GSListener)) +#define GS_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_LISTENER, GSListenerClass)) +#define GS_IS_LISTENER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_LISTENER)) +#define GS_IS_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_LISTENER)) +#define GS_LISTENER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_LISTENER, GSListenerClass)) + +typedef struct GSListenerPrivate GSListenerPrivate; + +typedef struct +{ + GObject parent; + GSListenerPrivate *priv; +} GSListener; + +typedef struct +{ + GObjectClass parent_class; + + void (* lock) (GSListener *listener); + void (* cycle) (GSListener *listener); + void (* quit) (GSListener *listener); + void (* simulate_user_activity) (GSListener *listener); + gboolean (* active_changed) (GSListener *listener, + gboolean active); + void (* throttle_changed) (GSListener *listener, + gboolean throttled); + void (* show_message) (GSListener *listener, + const char *summary, + const char *body, + const char *icon); + +} GSListenerClass; + +typedef enum +{ + GS_LISTENER_ERROR_SERVICE_UNAVAILABLE, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + GS_LISTENER_ERROR_ACTIVATION_FAILURE +} GSListenerError; + +#define GS_LISTENER_ERROR gs_listener_error_quark () + +GQuark gs_listener_error_quark (void); + +GType gs_listener_get_type (void); + +GSListener *gs_listener_new (void); +gboolean gs_listener_acquire (GSListener *listener, + GError **error); +gboolean gs_listener_set_active (GSListener *listener, + gboolean active); +gboolean gs_listener_set_session_idle (GSListener *listener, + gboolean idle); +void gs_listener_set_activation_enabled (GSListener *listener, + gboolean enabled); +gboolean gs_listener_get_activation_enabled (GSListener *listener); +gboolean gs_listener_is_inhibited (GSListener *listener); + +G_END_DECLS + +#endif /* __GS_LISTENER_H */ diff --git a/src/gs-listener-dbus.h.orig b/src/gs-listener-dbus.h.orig new file mode 100644 index 0000000..40a7e99 --- /dev/null +++ b/src/gs-listener-dbus.h.orig @@ -0,0 +1,89 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_LISTENER_H +#define __GS_LISTENER_H + +G_BEGIN_DECLS + +#define GS_TYPE_LISTENER (gs_listener_get_type ()) +#define GS_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_LISTENER, GSListener)) +#define GS_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_LISTENER, GSListenerClass)) +#define GS_IS_LISTENER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_LISTENER)) +#define GS_IS_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_LISTENER)) +#define GS_LISTENER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_LISTENER, GSListenerClass)) + +typedef struct GSListenerPrivate GSListenerPrivate; + +typedef struct +{ + GObject parent; + GSListenerPrivate *priv; +} GSListener; + +typedef struct +{ + GObjectClass parent_class; + + void (* lock) (GSListener *listener); + void (* cycle) (GSListener *listener); + void (* quit) (GSListener *listener); + void (* simulate_user_activity) (GSListener *listener); + gboolean (* active_changed) (GSListener *listener, + gboolean active); + void (* throttle_changed) (GSListener *listener, + gboolean throttled); + void (* show_message) (GSListener *listener, + const char *summary, + const char *body, + const char *icon); + +} GSListenerClass; + +typedef enum +{ + GS_LISTENER_ERROR_SERVICE_UNAVAILABLE, + GS_LISTENER_ERROR_ACQUISITION_FAILURE, + GS_LISTENER_ERROR_ACTIVATION_FAILURE +} GSListenerError; + +#define GS_LISTENER_ERROR gs_listener_error_quark () + +GQuark gs_listener_error_quark (void); + +GType gs_listener_get_type (void); + +GSListener *gs_listener_new (void); +gboolean gs_listener_acquire (GSListener *listener, + GError **error); +gboolean gs_listener_set_active (GSListener *listener, + gboolean active); +gboolean gs_listener_set_session_idle (GSListener *listener, + gboolean idle); +void gs_listener_set_activation_enabled (GSListener *listener, + gboolean enabled); +gboolean gs_listener_get_activation_enabled (GSListener *listener); +gboolean gs_listener_is_inhibited (GSListener *listener); + +G_END_DECLS + +#endif /* __GS_LISTENER_H */ diff --git a/src/gs-lock-plug.c b/src/gs-lock-plug.c new file mode 100644 index 0000000..81bea13 --- /dev/null +++ b/src/gs-lock-plug.c @@ -0,0 +1,2050 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef WITH_KBD_LAYOUT_INDICATOR +#include +#endif + +#ifdef WITH_LIBMATENOTIFY +#include +#endif + +#include "gs-lock-plug.h" + +#include "gs-debug.h" + +#define KEY_LOCK_DIALOG_THEME "/apps/mate-screensaver/lock_dialog_theme" +#define MDM_FLEXISERVER_COMMAND "mdmflexiserver" +#define MDM_FLEXISERVER_ARGS "--startnew Standard" + +/* same as SMS ;) */ +#define NOTE_BUFFER_MAX_CHARS 160 + +enum +{ + AUTH_PAGE = 0, +}; + +#define FACE_ICON_SIZE 48 +#define DIALOG_TIMEOUT_MSEC 60000 + +static void gs_lock_plug_finalize (GObject *object); + +#define GS_LOCK_PLUG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_LOCK_PLUG, GSLockPlugPrivate)) + +struct GSLockPlugPrivate +{ + GtkWidget *vbox; + GtkWidget *auth_action_area; + + GtkWidget *notebook; + GtkWidget *auth_face_image; + GtkWidget *auth_realname_label; + GtkWidget *auth_username_label; + GtkWidget *auth_prompt_label; + GtkWidget *auth_prompt_entry; + GtkWidget *auth_prompt_box; + GtkWidget *auth_capslock_label; + GtkWidget *auth_message_label; + GtkWidget *status_message_label; + + GtkWidget *auth_unlock_button; + GtkWidget *auth_switch_button; + GtkWidget *auth_cancel_button; + GtkWidget *auth_logout_button; + GtkWidget *auth_note_button; + GtkWidget *note_tab; + GtkWidget *note_tab_label; + GtkWidget *note_text_view; + GtkWidget *note_ok_button; + GtkWidget *note_cancel_button; + + GtkWidget *auth_prompt_kbd_layout_indicator; + + gboolean caps_lock_on; + gboolean switch_enabled; + gboolean leave_note_enabled; + gboolean logout_enabled; + char *logout_command; + char *status_message; + + guint timeout; + + guint cancel_timeout_id; + guint auth_check_idle_id; + guint response_idle_id; + + GList *key_events; +}; + +typedef struct _ResponseData ResponseData; + +struct _ResponseData +{ + gint response_id; +}; + + +enum +{ + RESPONSE, + CLOSE, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_LOGOUT_ENABLED, + PROP_LOGOUT_COMMAND, + PROP_SWITCH_ENABLED, + PROP_STATUS_MESSAGE +}; + +static guint lock_plug_signals [LAST_SIGNAL]; + +G_DEFINE_TYPE (GSLockPlug, gs_lock_plug, GTK_TYPE_PLUG) + +static void +gs_lock_plug_style_set (GtkWidget *widget, + GtkStyle *previous_style) +{ + GSLockPlug *plug; + + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->style_set) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->style_set (widget, previous_style); + } + + plug = GS_LOCK_PLUG (widget); + + if (! plug->priv->vbox) + { + return; + } + + gtk_container_set_border_width (GTK_CONTAINER (plug->priv->vbox), 12); + gtk_box_set_spacing (GTK_BOX (plug->priv->vbox), 12); + + gtk_container_set_border_width (GTK_CONTAINER (plug->priv->auth_action_area), 0); + gtk_box_set_spacing (GTK_BOX (plug->priv->auth_action_area), 5); +} + +static void +do_user_switch (GSLockPlug *plug) +{ + GError *error; + gboolean res; + char *command; + + command = g_strdup_printf ("%s %s", + MDM_FLEXISERVER_COMMAND, + MDM_FLEXISERVER_ARGS); + + error = NULL; + res = gdk_spawn_command_line_on_screen (gdk_screen_get_default (), + command, + &error); + + g_free (command); + + if (! res) + { + gs_debug ("Unable to start MDM greeter: %s", error->message); + g_error_free (error); + } +} + +static void +set_status_text (GSLockPlug *plug, + const char *text) +{ + if (plug->priv->auth_message_label != NULL) + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_message_label), text); + } +} + +void +gs_lock_plug_set_sensitive (GSLockPlug *plug, + gboolean sensitive) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, sensitive); + gtk_widget_set_sensitive (plug->priv->auth_action_area, sensitive); +} + +static void +remove_cancel_timeout (GSLockPlug *plug) +{ + if (plug->priv->cancel_timeout_id > 0) + { + g_source_remove (plug->priv->cancel_timeout_id); + plug->priv->cancel_timeout_id = 0; + } +} + +static void +remove_response_idle (GSLockPlug *plug) +{ + if (plug->priv->response_idle_id > 0) + { + g_source_remove (plug->priv->response_idle_id); + plug->priv->response_idle_id = 0; + } +} + +static void +gs_lock_plug_response (GSLockPlug *plug, + gint response_id) +{ + int new_response; + + new_response = response_id; + + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + /* Act only on response IDs we recognize */ + if (!(response_id == GS_LOCK_PLUG_RESPONSE_OK + || response_id == GS_LOCK_PLUG_RESPONSE_CANCEL)) + { + return; + } + + remove_cancel_timeout (plug); + remove_response_idle (plug); + + if (response_id == GS_LOCK_PLUG_RESPONSE_CANCEL) + { + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), ""); + } + + g_signal_emit (plug, + lock_plug_signals [RESPONSE], + 0, + new_response); +} + +static gboolean +response_cancel_idle_cb (GSLockPlug *plug) +{ + plug->priv->response_idle_id = 0; + + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); + + return FALSE; +} + +static gboolean +dialog_timed_out (GSLockPlug *plug) +{ + gs_lock_plug_set_sensitive (plug, FALSE); + set_status_text (plug, _("Time has expired.")); + + if (plug->priv->response_idle_id != 0) + { + g_warning ("Response idle ID already set but shouldn't be"); + } + + remove_response_idle (plug); + + plug->priv->response_idle_id = g_timeout_add (2000, + (GSourceFunc)response_cancel_idle_cb, + plug); + return FALSE; +} + + +static void +capslock_update (GSLockPlug *plug, + gboolean is_on) +{ + + plug->priv->caps_lock_on = is_on; + + if (plug->priv->auth_capslock_label == NULL) + { + return; + } + + if (is_on) + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_capslock_label), + _("You have the Caps Lock key on.")); + } + else + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_capslock_label), + ""); + } +} + +static gboolean +is_capslock_on (void) +{ + XkbStateRec states; + Display *dsp; + + dsp = GDK_DISPLAY (); + if (XkbGetState (dsp, XkbUseCoreKbd, &states) != Success) + { + return FALSE; + } + + return (states.locked_mods & LockMask) != 0; +} + +static void +restart_cancel_timeout (GSLockPlug *plug) +{ + remove_cancel_timeout (plug); + + plug->priv->cancel_timeout_id = g_timeout_add (plug->priv->timeout, + (GSourceFunc)dialog_timed_out, + plug); +} + +void +gs_lock_plug_get_text (GSLockPlug *plug, + char **text) +{ + const char *typed_text; + char *null_text; + char *local_text; + + typed_text = gtk_entry_get_text (GTK_ENTRY (plug->priv->auth_prompt_entry)); + local_text = g_locale_from_utf8 (typed_text, strlen (typed_text), NULL, NULL, NULL); + + null_text = g_strnfill (strlen (typed_text) + 1, '\b'); + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), null_text); + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), ""); + g_free (null_text); + + if (text != NULL) + { + *text = local_text; + } +} + +typedef struct +{ + GSLockPlug *plug; + gint response_id; + GMainLoop *loop; + gboolean destroyed; +} RunInfo; + +static void +shutdown_loop (RunInfo *ri) +{ + if (g_main_loop_is_running (ri->loop)) + g_main_loop_quit (ri->loop); +} + +static void +run_unmap_handler (GSLockPlug *plug, + gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); +} + +static void +run_response_handler (GSLockPlug *plug, + gint response_id, + gpointer data) +{ + RunInfo *ri; + + ri = data; + + ri->response_id = response_id; + + shutdown_loop (ri); +} + +static gint +run_delete_handler (GSLockPlug *plug, + GdkEventAny *event, + gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); + + return TRUE; /* Do not destroy */ +} + +static void +run_destroy_handler (GSLockPlug *plug, + gpointer data) +{ + RunInfo *ri = data; + + /* shutdown_loop will be called by run_unmap_handler */ + ri->destroyed = TRUE; +} + +/* adapted from GTK+ gtkdialog.c */ +int +gs_lock_plug_run (GSLockPlug *plug) +{ + RunInfo ri = { NULL, GTK_RESPONSE_NONE, NULL, FALSE }; + gboolean was_modal; + gulong response_handler; + gulong unmap_handler; + gulong destroy_handler; + gulong delete_handler; + + g_return_val_if_fail (GS_IS_LOCK_PLUG (plug), -1); + + g_object_ref (plug); + + was_modal = GTK_WINDOW (plug)->modal; + if (!was_modal) + { + gtk_window_set_modal (GTK_WINDOW (plug), TRUE); + } + + if (!GTK_WIDGET_VISIBLE (plug)) + { + gtk_widget_show (GTK_WIDGET (plug)); + } + + response_handler = + g_signal_connect (plug, + "response", + G_CALLBACK (run_response_handler), + &ri); + + unmap_handler = + g_signal_connect (plug, + "unmap", + G_CALLBACK (run_unmap_handler), + &ri); + + delete_handler = + g_signal_connect (plug, + "delete_event", + G_CALLBACK (run_delete_handler), + &ri); + + destroy_handler = + g_signal_connect (plug, + "destroy", + G_CALLBACK (run_destroy_handler), + &ri); + + ri.loop = g_main_loop_new (NULL, FALSE); + + GDK_THREADS_LEAVE (); + g_main_loop_run (ri.loop); + GDK_THREADS_ENTER (); + + g_main_loop_unref (ri.loop); + + ri.loop = NULL; + + if (!ri.destroyed) + { + if (! was_modal) + { + gtk_window_set_modal (GTK_WINDOW (plug), FALSE); + } + + g_signal_handler_disconnect (plug, response_handler); + g_signal_handler_disconnect (plug, unmap_handler); + g_signal_handler_disconnect (plug, delete_handler); + g_signal_handler_disconnect (plug, destroy_handler); + } + + g_object_unref (plug); + + return ri.response_id; +} + + +static cairo_surface_t * +surface_from_pixbuf (GdkPixbuf *pixbuf) +{ + cairo_surface_t *surface; + cairo_t *cr; + + surface = cairo_image_surface_create (gdk_pixbuf_get_has_alpha (pixbuf) ? + CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24, + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf)); + cr = cairo_create (surface); + gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); + cairo_paint (cr); + cairo_destroy (cr); + + return surface; +} + +static void +rounded_rectangle (cairo_t *cr, + gdouble aspect, + gdouble x, + gdouble y, + gdouble corner_radius, + gdouble width, + gdouble height) +{ + gdouble radius; + gdouble degrees; + + radius = corner_radius / aspect; + degrees = G_PI / 180.0; + + cairo_new_sub_path (cr); + cairo_arc (cr, + x + width - radius, + y + radius, + radius, + -90 * degrees, + 0 * degrees); + cairo_arc (cr, + x + width - radius, + y + height - radius, + radius, + 0 * degrees, + 90 * degrees); + cairo_arc (cr, + x + radius, + y + height - radius, + radius, + 90 * degrees, + 180 * degrees); + cairo_arc (cr, + x + radius, + y + radius, + radius, + 180 * degrees, + 270 * degrees); + cairo_close_path (cr); +} + +static void +image_set_from_pixbuf (GtkImage *image, + GdkPixbuf *source) +{ + cairo_t *cr; + cairo_t *cr_mask; + cairo_surface_t *surface; + GdkPixmap *pixmap; + GdkPixmap *bitmask; + int w; + int h; + int frame_width; + double radius; + GdkColor color; + double r; + double g; + double b; + + frame_width = 5; + + w = gdk_pixbuf_get_width (source) + frame_width * 2; + h = gdk_pixbuf_get_height (source) + frame_width * 2; + + radius = w / 10; + + pixmap = gdk_pixmap_new (GTK_WIDGET (image)->window, w, h, -1); + bitmask = gdk_pixmap_new (GTK_WIDGET (image)->window, w, h, 1); + + cr = gdk_cairo_create (pixmap); + cr_mask = gdk_cairo_create (bitmask); + + /* setup mask */ + cairo_rectangle (cr_mask, 0, 0, w, h); + cairo_set_operator (cr_mask, CAIRO_OPERATOR_CLEAR); + cairo_fill (cr_mask); + + rounded_rectangle (cr_mask, 1.0, 0.5, 0.5, radius, w - 1, h - 1); + cairo_set_operator (cr_mask, CAIRO_OPERATOR_OVER); + cairo_set_source_rgb (cr_mask, 1, 1, 1); + cairo_fill (cr_mask); + + color = GTK_WIDGET (image)->style->bg [GTK_STATE_NORMAL]; + r = (float)color.red / 65535.0; + g = (float)color.green / 65535.0; + b = (float)color.blue / 65535.0; + + /* set up image */ + cairo_rectangle (cr, 0, 0, w, h); + cairo_set_source_rgb (cr, r, g, b); + cairo_fill (cr); + + rounded_rectangle (cr, + 1.0, + frame_width + 0.5, + frame_width + 0.5, + radius, + w - frame_width * 2 - 1, + h - frame_width * 2 - 1); + cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 0.3); + cairo_fill_preserve (cr); + + surface = surface_from_pixbuf (source); + cairo_set_source_surface (cr, surface, frame_width, frame_width); + cairo_fill (cr); + + gtk_image_set_from_pixmap (image, pixmap, bitmask); + + cairo_surface_destroy (surface); + + g_object_unref (bitmask); + g_object_unref (pixmap); + + cairo_destroy (cr_mask); + cairo_destroy (cr); +} + + +static gboolean +check_user_file (const gchar *filename, + uid_t user, + gssize max_file_size, + gboolean relax_group, + gboolean relax_other) +{ + struct stat fileinfo; + + if (max_file_size < 0) + { + max_file_size = G_MAXSIZE; + } + + /* Exists/Readable? */ + if (g_stat (filename, &fileinfo) < 0) + { + return FALSE; + } + + /* Is a regular file */ + if (G_UNLIKELY (!S_ISREG (fileinfo.st_mode))) + { + return FALSE; + } + + /* Owned by user? */ + if (G_UNLIKELY (fileinfo.st_uid != user)) + { + return FALSE; + } + + /* Group not writable or relax_group? */ + if (G_UNLIKELY ((fileinfo.st_mode & S_IWGRP) == S_IWGRP && !relax_group)) + { + return FALSE; + } + + /* Other not writable or relax_other? */ + if (G_UNLIKELY ((fileinfo.st_mode & S_IWOTH) == S_IWOTH && !relax_other)) + { + return FALSE; + } + + /* Size is kosher? */ + if (G_UNLIKELY (fileinfo.st_size > max_file_size)) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +set_face_image (GSLockPlug *plug) +{ + GdkPixbuf *pixbuf; + const char *homedir; + char *path; + int icon_size = 96; + gsize user_max_file = 65536; + uid_t uid; + + homedir = g_get_home_dir (); + uid = getuid (); + + path = g_build_filename (homedir, ".face", NULL); + + pixbuf = NULL; + if (check_user_file (path, uid, user_max_file, 0, 0)) + { + pixbuf = gdk_pixbuf_new_from_file_at_size (path, + icon_size, + icon_size, + NULL); + } + + g_free (path); + + if (pixbuf == NULL) + { + return FALSE; + } + + image_set_from_pixbuf (GTK_IMAGE (plug->priv->auth_face_image), pixbuf); + + g_object_unref (pixbuf); + + return TRUE; +} + +static void +gs_lock_plug_show (GtkWidget *widget) +{ + GSLockPlug *plug = GS_LOCK_PLUG (widget); + + gs_profile_start (NULL); + + gs_profile_start ("parent"); + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->show) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->show (widget); + } + + gs_profile_end ("parent"); + + + if (plug->priv->auth_face_image) + { + set_face_image (plug); + } + + capslock_update (plug, is_capslock_on ()); + + restart_cancel_timeout (plug); + + gs_profile_end (NULL); +} + +static void +gs_lock_plug_hide (GtkWidget *widget) +{ + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->hide) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->hide (widget); + } +} + +static void +queue_key_event (GSLockPlug *plug, + GdkEventKey *event) +{ + GdkEvent *saved_event; + + saved_event = gdk_event_copy ((GdkEvent *)event); + plug->priv->key_events = g_list_prepend (plug->priv->key_events, + saved_event); +} + +static void +forward_key_events (GSLockPlug *plug) +{ + plug->priv->key_events = g_list_reverse (plug->priv->key_events); + while (plug->priv->key_events != NULL) + { + GdkEventKey *event = plug->priv->key_events->data; + + gtk_window_propagate_key_event (GTK_WINDOW (plug), event); + + gdk_event_free ((GdkEvent *)event); + + plug->priv->key_events = g_list_delete_link (plug->priv->key_events, + plug->priv->key_events); + } +} + +static void +gs_lock_plug_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GSLockPlug *plug = GS_LOCK_PLUG (widget); + int mod_width; + int mod_height; + + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->size_request) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->size_request (widget, requisition); + } + + /* don't constrain size when themed */ + if (plug->priv->vbox == NULL) + { + return; + } + + mod_width = requisition->height * 1.3; + mod_height = requisition->width / 1.6; + if (requisition->width < mod_width) + { + /* if the dialog is tall fill out the width */ + requisition->width = mod_width; + } + else if (requisition->height < mod_height) + { + /* if the dialog is wide fill out the height */ + requisition->height = mod_height; + } +} + +static void +gs_lock_plug_set_logout_enabled (GSLockPlug *plug, + gboolean logout_enabled) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + if (plug->priv->logout_enabled == logout_enabled) + { + return; + } + + plug->priv->logout_enabled = logout_enabled; + g_object_notify (G_OBJECT (plug), "logout-enabled"); + + if (plug->priv->auth_logout_button == NULL) + { + return; + } + + if (logout_enabled) + { + gtk_widget_show (plug->priv->auth_logout_button); + } + else + { + gtk_widget_hide (plug->priv->auth_logout_button); + } +} + +static void +gs_lock_plug_set_logout_command (GSLockPlug *plug, + const char *command) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + g_free (plug->priv->logout_command); + + if (command) + { + plug->priv->logout_command = g_strdup (command); + } + else + { + plug->priv->logout_command = NULL; + } +} + +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 +gs_lock_plug_set_status_message (GSLockPlug *plug, + const char *status_message) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + g_free (plug->priv->status_message); + plug->priv->status_message = g_strdup (status_message); + + if (plug->priv->status_message_label) + { + if (plug->priv->status_message) + { + gtk_label_set_text (GTK_LABEL (plug->priv->status_message_label), + plug->priv->status_message); + gtk_widget_show (plug->priv->status_message_label); + } + else + { + gtk_widget_hide (plug->priv->status_message_label); + } + } +} + +static void +gs_lock_plug_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSLockPlug *self; + + self = GS_LOCK_PLUG (object); + + switch (prop_id) + { + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_SWITCH_ENABLED: + g_value_set_boolean (value, self->priv->switch_enabled); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_lock_plug_set_switch_enabled (GSLockPlug *plug, + gboolean switch_enabled) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + if (plug->priv->switch_enabled == switch_enabled) + { + return; + } + + plug->priv->switch_enabled = switch_enabled; + g_object_notify (G_OBJECT (plug), "switch-enabled"); + + if (plug->priv->auth_switch_button == NULL) + { + return; + } + + if (switch_enabled) + { + gboolean found; + found = is_program_in_path (MDM_FLEXISERVER_COMMAND); + if (found) + { + gtk_widget_show (plug->priv->auth_switch_button); + } + else + { + gs_debug ("Waring: MDM flexiserver command not found: %s", MDM_FLEXISERVER_COMMAND); + gtk_widget_hide (plug->priv->auth_switch_button); + } + } + else + { + gtk_widget_hide (plug->priv->auth_switch_button); + } +} + +static void +gs_lock_plug_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSLockPlug *self; + + self = GS_LOCK_PLUG (object); + + switch (prop_id) + { + case PROP_LOGOUT_ENABLED: + gs_lock_plug_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_lock_plug_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_lock_plug_set_status_message (self, g_value_get_string (value)); + break; + case PROP_SWITCH_ENABLED: + gs_lock_plug_set_switch_enabled (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_lock_plug_close (GSLockPlug *plug) +{ + /* Synthesize delete_event to close dialog. */ + + GtkWidget *widget = GTK_WIDGET (plug); + GdkEvent *event; + + event = gdk_event_new (GDK_DELETE); + event->any.window = g_object_ref (widget->window); + event->any.send_event = TRUE; + + gtk_main_do_event (event); + gdk_event_free (event); +} + +static void +gs_lock_plug_class_init (GSLockPlugClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GtkBindingSet *binding_set; + + object_class->finalize = gs_lock_plug_finalize; + object_class->get_property = gs_lock_plug_get_property; + object_class->set_property = gs_lock_plug_set_property; + + widget_class->style_set = gs_lock_plug_style_set; + widget_class->show = gs_lock_plug_show; + widget_class->hide = gs_lock_plug_hide; + widget_class->size_request = gs_lock_plug_size_request; + + klass->close = gs_lock_plug_close; + + g_type_class_add_private (klass, sizeof (GSLockPlugPrivate)); + + lock_plug_signals [RESPONSE] = g_signal_new ("response", + G_OBJECT_CLASS_TYPE (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSLockPlugClass, response), + NULL, NULL, + g_cclosure_marshal_VOID__INT, + G_TYPE_NONE, 1, + G_TYPE_INT); + lock_plug_signals [CLOSE] = g_signal_new ("close", + G_OBJECT_CLASS_TYPE (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GSLockPlugClass, close), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_SWITCH_ENABLED, + g_param_spec_boolean ("switch-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + + binding_set = gtk_binding_set_by_class (klass); + + gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0, + "close", 0); +} + +static void +clear_clipboards (GSLockPlug *plug) +{ + GtkClipboard *clipboard; + + clipboard = gtk_widget_get_clipboard (GTK_WIDGET (plug), GDK_SELECTION_PRIMARY); + gtk_clipboard_clear (clipboard); + gtk_clipboard_set_text (clipboard, "", -1); + clipboard = gtk_widget_get_clipboard (GTK_WIDGET (plug), GDK_SELECTION_CLIPBOARD); + gtk_clipboard_clear (clipboard); + gtk_clipboard_set_text (clipboard, "", -1); +} + +static void +take_note (GtkButton *button, + GSLockPlug *plug) +{ + int page; + + page = gtk_notebook_page_num (GTK_NOTEBOOK (plug->priv->notebook), plug->priv->note_tab); + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), page); + /* this counts as activity so restart the timer */ + restart_cancel_timeout (plug); +} + +static void +submit_note (GtkButton *button, + GSLockPlug *plug) +{ +#ifdef WITH_LIBMATENOTIFY + char *text; + char summary[128]; + char *escaped_text; + GtkTextBuffer *buffer; + GtkTextIter start, end; + time_t t; + struct tm *tmp; + NotifyNotification *note; + + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), AUTH_PAGE); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); + gtk_text_buffer_set_text (buffer, "", 0); + escaped_text = g_markup_escape_text (text, -1); + + t = time (NULL); + tmp = localtime (&t); + strftime (summary, 128, "%X", tmp); + + notify_init ("mate-screensaver-dialog"); + note = notify_notification_new (summary, escaped_text, NULL, NULL); + notify_notification_set_timeout (note, NOTIFY_EXPIRES_NEVER); + notify_notification_show (note, NULL); + g_object_unref (note); + + g_free (text); + g_free (escaped_text); + + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); +#endif /* WITH_LIBMATENOTIFY */ +} + +static void +cancel_note (GtkButton *button, + GSLockPlug *plug) +{ + GtkTextBuffer *buffer; + + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), AUTH_PAGE); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + gtk_text_buffer_set_text (buffer, "", 0); + + /* this counts as activity so restart the timer */ + restart_cancel_timeout (plug); + + gtk_window_set_default (GTK_WINDOW (plug), plug->priv->auth_unlock_button); + + clear_clipboards (plug); +} + +static void +logout_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + char **argv = NULL; + GError *error = NULL; + gboolean res; + + if (! plug->priv->logout_command) + { + return; + } + + res = g_shell_parse_argv (plug->priv->logout_command, NULL, &argv, &error); + + if (! res) + { + g_warning ("Could not parse logout command: %s", error->message); + g_error_free (error); + return; + } + + g_spawn_async (g_get_home_dir (), + argv, + NULL, + G_SPAWN_SEARCH_PATH, + NULL, + NULL, + NULL, + &error); + + g_strfreev (argv); + + if (error) + { + g_warning ("Could not run logout command: %s", error->message); + g_error_free (error); + } +} + +void +gs_lock_plug_set_busy (GSLockPlug *plug) +{ + GdkCursor *cursor; + GtkWidget *top_level; + + top_level = gtk_widget_get_toplevel (GTK_WIDGET (plug)); + + cursor = gdk_cursor_new (GDK_WATCH); + gdk_window_set_cursor (top_level->window, cursor); + gdk_cursor_unref (cursor); +} + +void +gs_lock_plug_set_ready (GSLockPlug *plug) +{ + GdkCursor *cursor; + GtkWidget *top_level; + + top_level = gtk_widget_get_toplevel (GTK_WIDGET (plug)); + + cursor = gdk_cursor_new (GDK_LEFT_PTR); + gdk_window_set_cursor (top_level->window, cursor); + gdk_cursor_unref (cursor); +} + +void +gs_lock_plug_enable_prompt (GSLockPlug *plug, + const char *message, + gboolean visible) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + gs_debug ("Setting prompt to: %s", message); + + gtk_widget_set_sensitive (plug->priv->auth_unlock_button, TRUE); + gtk_widget_show (plug->priv->auth_unlock_button); + gtk_widget_grab_default (plug->priv->auth_unlock_button); + gtk_label_set_text (GTK_LABEL (plug->priv->auth_prompt_label), message); + gtk_widget_show (plug->priv->auth_prompt_label); + gtk_entry_set_visibility (GTK_ENTRY (plug->priv->auth_prompt_entry), visible); + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, TRUE); + gtk_widget_show (plug->priv->auth_prompt_entry); + + if (! GTK_WIDGET_HAS_FOCUS (plug->priv->auth_prompt_entry)) + { + gtk_widget_grab_focus (plug->priv->auth_prompt_entry); + } + + /* were there any key events sent to the plug while the + * entry wasnt ready? If so, forward them along + */ + forward_key_events (plug); + + restart_cancel_timeout (plug); +} + +void +gs_lock_plug_disable_prompt (GSLockPlug *plug) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + /* gtk_widget_hide (plug->priv->auth_prompt_entry); */ + /* gtk_widget_hide (plug->priv->auth_prompt_label); */ + gtk_widget_set_sensitive (plug->priv->auth_unlock_button, FALSE); + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, FALSE); + /* gtk_widget_hide (plug->priv->auth_unlock_button); */ + + gtk_widget_grab_default (plug->priv->auth_cancel_button); +} + +void +gs_lock_plug_show_message (GSLockPlug *plug, + const char *message) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + set_status_text (plug, message ? message : ""); +} + +/* button press handler used to inhibit popup menu */ +static gint +entry_button_press (GtkWidget *widget, + GdkEventButton *event) +{ + if (event->button == 3 && event->type == GDK_BUTTON_PRESS) + { + return TRUE; + } + + return FALSE; +} + +static gint +entry_key_press (GtkWidget *widget, + GdkEventKey *event, + GSLockPlug *plug) +{ + gboolean capslock_on; + + restart_cancel_timeout (plug); + + capslock_on = is_capslock_on (); + + if (capslock_on != plug->priv->caps_lock_on) + { + capslock_update (plug, capslock_on); + } + + /* if the input widget is visible and ready for input + * then just carry on as usual + */ + if (GTK_WIDGET_VISIBLE (plug->priv->auth_prompt_entry) && + GTK_WIDGET_IS_SENSITIVE (plug->priv->auth_prompt_entry)) + { + return FALSE; + } + + if (strcmp (event->string, "") == 0) + { + return FALSE; + } + + queue_key_event (plug, event); + + return TRUE; +} + +/* adapted from gtk_dialog_add_button */ +static GtkWidget * +gs_lock_plug_add_button (GSLockPlug *plug, + GtkWidget *action_area, + const gchar *button_text) +{ + GtkWidget *button; + + g_return_val_if_fail (GS_IS_LOCK_PLUG (plug), NULL); + g_return_val_if_fail (button_text != NULL, NULL); + + button = gtk_button_new_from_stock (button_text); + + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + + gtk_widget_show (button); + + gtk_box_pack_end (GTK_BOX (action_area), + button, + FALSE, TRUE, 0); + + return button; +} + +static char * +get_user_display_name (void) +{ + const char *name; + char *utf8_name; + + name = g_get_real_name (); + + if (name == NULL || strcmp (name, "Unknown") == 0) + { + name = g_get_user_name (); + } + + utf8_name = NULL; + + if (name != NULL) + { + utf8_name = g_locale_to_utf8 (name, -1, NULL, NULL, NULL); + } + + return utf8_name; +} + +static char * +get_user_name (void) +{ + const char *name; + char *utf8_name; + + name = g_get_user_name (); + + utf8_name = NULL; + if (name != NULL) + { + utf8_name = g_locale_to_utf8 (name, -1, NULL, NULL, NULL); + } + + return utf8_name; +} + +static void +create_page_one_buttons (GSLockPlug *plug) +{ + + gs_profile_start ("page one buttons"); + + plug->priv->auth_switch_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("S_witch User...")); + gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (plug->priv->auth_action_area), + plug->priv->auth_switch_button, + TRUE); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_switch_button), FALSE); + gtk_widget_set_no_show_all (plug->priv->auth_switch_button, TRUE); + + plug->priv->auth_logout_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("Log _Out")); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_logout_button), FALSE); + gtk_widget_set_no_show_all (plug->priv->auth_logout_button, TRUE); + + plug->priv->auth_cancel_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + GTK_STOCK_CANCEL); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_cancel_button), FALSE); + + plug->priv->auth_unlock_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("_Unlock")); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_unlock_button), FALSE); + + gtk_window_set_default (GTK_WINDOW (plug), plug->priv->auth_unlock_button); + + gs_profile_end ("page one buttons"); +} + +/* adapted from MDM */ +static char * +expand_string (const char *text) +{ + GString *str; + const char *p; + char *username; + int i; + int n_chars; + struct utsname name; + + str = g_string_sized_new (strlen (text)); + + p = text; + n_chars = g_utf8_strlen (text, -1); + i = 0; + + while (i < n_chars) + { + gunichar ch; + + ch = g_utf8_get_char (p); + + /* Backslash commands */ + if (ch == '\\') + { + p = g_utf8_next_char (p); + i++; + ch = g_utf8_get_char (p); + + if (i >= n_chars || ch == '\0') + { + g_warning ("Unescaped \\ at end of text\n"); + goto bail; + } + else if (ch == 'n') + { + g_string_append_unichar (str, '\n'); + } + else + { + g_string_append_unichar (str, ch); + } + } + else if (ch == '%') + { + p = g_utf8_next_char (p); + i++; + ch = g_utf8_get_char (p); + + if (i >= n_chars || ch == '\0') + { + g_warning ("Unescaped %% at end of text\n"); + goto bail; + } + + switch (ch) + { + case '%': + g_string_append (str, "%"); + break; + case 'c': + /* clock */ + break; + case 'd': + /* display */ + g_string_append (str, g_getenv ("DISPLAY")); + break; + case 'h': + /* hostname */ + g_string_append (str, g_get_host_name ()); + break; + case 'm': + /* machine name */ + uname (&name); + g_string_append (str, name.machine); + break; + case 'n': + /* nodename */ + uname (&name); + g_string_append (str, name.nodename); + break; + case 'r': + /* release */ + uname (&name); + g_string_append (str, name.release); + break; + case 'R': + /* Real name */ + username = get_user_display_name (); + g_string_append (str, username); + g_free (username); + break; + case 's': + /* system name */ + uname (&name); + g_string_append (str, name.sysname); + break; + case 'U': + /* Username */ + username = get_user_name (); + g_string_append (str, username); + g_free (username); + break; + default: + if (ch < 127) + { + g_warning ("unknown escape code %%%c in text\n", (char)ch); + } + else + { + g_warning ("unknown escape code %%(U%x) in text\n", (int)ch); + } + } + } + else + { + g_string_append_unichar (str, ch); + } + p = g_utf8_next_char (p); + i++; + } + +bail: + + return g_string_free (str, FALSE); +} + +static void +expand_string_for_label (GtkWidget *label) +{ + const char *template; + char *str; + + template = gtk_label_get_label (GTK_LABEL (label)); + str = expand_string (template); + gtk_label_set_label (GTK_LABEL (label), str); + g_free (str); +} + +static void +create_page_one (GSLockPlug *plug) +{ + GtkWidget *align; + GtkWidget *vbox; + GtkWidget *vbox2; + GtkWidget *hbox; + char *str; + + gs_profile_start ("page one"); + + align = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_notebook_append_page (GTK_NOTEBOOK (plug->priv->notebook), align, NULL); + + vbox = gtk_vbox_new (FALSE, 12); + gtk_container_add (GTK_CONTAINER (align), vbox); + + plug->priv->auth_face_image = gtk_image_new (); + gtk_box_pack_start (GTK_BOX (vbox), plug->priv->auth_face_image, TRUE, TRUE, 0); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_face_image), 0.5, 1.0); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); + + str = g_strdup ("%R"); + plug->priv->auth_realname_label = gtk_label_new (str); + g_free (str); + expand_string_for_label (plug->priv->auth_realname_label); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_realname_label), 0.5, 0.5); + gtk_label_set_use_markup (GTK_LABEL (plug->priv->auth_realname_label), TRUE); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_realname_label, FALSE, FALSE, 0); + + /* To translators: This expands to USERNAME on HOSTNAME */ + str = g_strdup_printf ("%s", _("%U on %h")); + plug->priv->auth_username_label = gtk_label_new (str); + g_free (str); + expand_string_for_label (plug->priv->auth_username_label); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_username_label), 0.5, 0.5); + gtk_label_set_use_markup (GTK_LABEL (plug->priv->auth_username_label), TRUE); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_username_label, FALSE, FALSE, 0); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); + + plug->priv->auth_prompt_label = gtk_label_new_with_mnemonic (_("_Password:")); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_prompt_label), 0, 0.5); + gtk_box_pack_start (GTK_BOX (hbox), plug->priv->auth_prompt_label, FALSE, FALSE, 0); + + plug->priv->auth_prompt_entry = gtk_entry_new (); + gtk_box_pack_start (GTK_BOX (hbox), plug->priv->auth_prompt_entry, TRUE, TRUE, 0); + + gtk_label_set_mnemonic_widget (GTK_LABEL (plug->priv->auth_prompt_label), + plug->priv->auth_prompt_entry); + + plug->priv->auth_capslock_label = gtk_label_new (""); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_capslock_label), 0.5, 0.5); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_capslock_label, FALSE, FALSE, 0); + + /* Status text */ + + plug->priv->auth_message_label = gtk_label_new (NULL); + gtk_box_pack_start (GTK_BOX (vbox), plug->priv->auth_message_label, + FALSE, FALSE, 0); + /* Buttons */ + plug->priv->auth_action_area = gtk_hbutton_box_new (); + + gtk_button_box_set_layout (GTK_BUTTON_BOX (plug->priv->auth_action_area), + GTK_BUTTONBOX_END); + + gtk_box_pack_end (GTK_BOX (vbox), plug->priv->auth_action_area, + FALSE, TRUE, 0); + gtk_widget_show (plug->priv->auth_action_area); + + create_page_one_buttons (plug); + + gs_profile_end ("page one"); +} + +static void +unlock_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_OK); +} + +static void +cancel_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); +} + +static void +switch_user_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + + remove_response_idle (plug); + + gs_lock_plug_set_sensitive (plug, FALSE); + + plug->priv->response_idle_id = g_timeout_add (2000, + (GSourceFunc)response_cancel_idle_cb, + plug); + + gs_lock_plug_set_busy (plug); + do_user_switch (plug); +} + +static char * +get_dialog_theme_name (GSLockPlug *plug) +{ + char *name; + MateConfClient *client; + + client = mateconf_client_get_default (); + name = mateconf_client_get_string (client, KEY_LOCK_DIALOG_THEME, NULL); + g_object_unref (client); + + return name; +} + +static gboolean +load_theme (GSLockPlug *plug) +{ + char *theme; + char *filename; + char *gtkbuilder; + char *rc; + GtkBuilder *builder; + GtkWidget *lock_dialog; + GError *error=NULL; + + theme = get_dialog_theme_name (plug); + if (theme == NULL) + { + return FALSE; + } + + filename = g_strdup_printf ("lock-dialog-%s.ui", theme); + gtkbuilder = g_build_filename (GTKBUILDERDIR, filename, NULL); + g_free (filename); + if (! g_file_test (gtkbuilder, G_FILE_TEST_IS_REGULAR)) + { + g_free (gtkbuilder); + g_free (theme); + return FALSE; + } + + filename = g_strdup_printf ("lock-dialog-%s.gtkrc", theme); + g_free (theme); + + rc = g_build_filename (GTKBUILDERDIR, filename, NULL); + g_free (filename); + if (g_file_test (rc, G_FILE_TEST_IS_REGULAR)) + { + gtk_rc_parse (rc); + } + g_free (rc); + + builder = gtk_builder_new(); + + if (!gtk_builder_add_from_file (builder,gtkbuilder,&error)) + { + g_warning ("Couldn't load builder file '%s': %s", gtkbuilder, error->message); + g_error_free(error); + g_free (gtkbuilder); + return FALSE; + } + g_free (gtkbuilder); + + lock_dialog = GTK_WIDGET (gtk_builder_get_object(builder, "lock-dialog")); + gtk_container_add (GTK_CONTAINER (plug), lock_dialog); + + plug->priv->vbox = NULL; + plug->priv->notebook = GTK_WIDGET (gtk_builder_get_object(builder, "notebook")); + + plug->priv->auth_face_image = GTK_WIDGET (gtk_builder_get_object(builder, "auth-face-image")); + plug->priv->auth_action_area = GTK_WIDGET (gtk_builder_get_object(builder, "auth-action-area")); + plug->priv->auth_realname_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-realname-label")); + plug->priv->auth_username_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-username-label")); + plug->priv->auth_prompt_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-label")); + plug->priv->auth_prompt_entry = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-entry")); + plug->priv->auth_prompt_box = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-box")); + plug->priv->auth_capslock_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-capslock-label")); + plug->priv->auth_message_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-status-label")); + plug->priv->auth_unlock_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-unlock-button")); + plug->priv->auth_cancel_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-cancel-button")); + plug->priv->auth_logout_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-logout-button")); + plug->priv->auth_switch_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-switch-button")); + plug->priv->auth_note_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-note-button")); + plug->priv->note_tab = GTK_WIDGET (gtk_builder_get_object(builder, "note-tab")); + plug->priv->note_tab_label = GTK_WIDGET (gtk_builder_get_object(builder, "note-tab-label")); + plug->priv->note_ok_button = GTK_WIDGET (gtk_builder_get_object(builder, "note-ok-button")); + plug->priv->note_text_view = GTK_WIDGET (gtk_builder_get_object(builder, "note-text-view")); + plug->priv->note_cancel_button = GTK_WIDGET (gtk_builder_get_object(builder, "note-cancel-button")); + + /* Placeholder for the keyboard indicator */ + plug->priv->auth_prompt_kbd_layout_indicator = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-kbd-layout-indicator")); + if (plug->priv->auth_logout_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_logout_button, TRUE); + } + if (plug->priv->auth_switch_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_switch_button, TRUE); + } + if (plug->priv->auth_note_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_note_button, TRUE); + } + + gtk_widget_show_all (lock_dialog); + + plug->priv->status_message_label = GTK_WIDGET (gtk_builder_get_object(builder, "status-message-label")); + + return TRUE; +} + +static int +delete_handler (GSLockPlug *plug, + GdkEventAny *event, + gpointer data) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); + + return TRUE; /* Do not destroy */ +} + +static void +on_note_text_buffer_changed (GtkTextBuffer *buffer, + GSLockPlug *plug) +{ + int len; + + len = gtk_text_buffer_get_char_count (buffer); + if (len > NOTE_BUFFER_MAX_CHARS) + { + gtk_widget_set_sensitive (plug->priv->note_text_view, FALSE); + } +} + +static void +gs_lock_plug_init (GSLockPlug *plug) +{ + gs_profile_start (NULL); + + plug->priv = GS_LOCK_PLUG_GET_PRIVATE (plug); + + clear_clipboards (plug); + +#ifdef WITH_LIBMATENOTIFY + plug->priv->leave_note_enabled = TRUE; +#else + plug->priv->leave_note_enabled = FALSE; +#endif + + if (! load_theme (plug)) + { + gs_debug ("Unable to load theme!"); + + plug->priv->vbox = gtk_vbox_new (FALSE, 0); + + gtk_container_add (GTK_CONTAINER (plug), plug->priv->vbox); + + /* Notebook */ + + plug->priv->notebook = gtk_notebook_new (); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (plug->priv->notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (plug->priv->notebook), FALSE); + gtk_box_pack_start (GTK_BOX (plug->priv->vbox), plug->priv->notebook, TRUE, TRUE, 0); + + /* Page 1 */ + + create_page_one (plug); + + gtk_widget_show_all (plug->priv->vbox); + } + + if (plug->priv->note_text_view != NULL) + { + GtkTextBuffer *buffer; + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + g_signal_connect (buffer, "changed", G_CALLBACK (on_note_text_buffer_changed), plug); + } + + /* Layout indicator */ +#ifdef WITH_KBD_LAYOUT_INDICATOR + if (plug->priv->auth_prompt_kbd_layout_indicator != NULL) + { + XklEngine *engine; + + engine = xkl_engine_get_instance (GDK_DISPLAY ()); + if (xkl_engine_get_num_groups (engine) > 1) + { + GtkWidget *layout_indicator; + + layout_indicator = matekbd_indicator_new (); + matekbd_indicator_set_parent_tooltips (MATEKBD_INDICATOR (layout_indicator), TRUE); + gtk_box_pack_start (GTK_BOX (plug->priv->auth_prompt_kbd_layout_indicator), + layout_indicator, + FALSE, + FALSE, + 6); + + gtk_widget_show_all (layout_indicator); + gtk_widget_show (plug->priv->auth_prompt_kbd_layout_indicator); + } + else + { + gtk_widget_hide (plug->priv->auth_prompt_kbd_layout_indicator); + } + + g_object_unref (engine); + } +#endif + + if (plug->priv->auth_note_button != NULL) + { + if (plug->priv->leave_note_enabled) + { + gtk_widget_show_all (plug->priv->auth_note_button); + } + else + { + gtk_widget_hide (plug->priv->auth_note_button); + } + } + if (plug->priv->auth_switch_button != NULL) + { + if (plug->priv->switch_enabled) + { + gtk_widget_show_all (plug->priv->auth_switch_button); + } + else + { + gtk_widget_hide (plug->priv->auth_switch_button); + } + } + + gtk_widget_grab_default (plug->priv->auth_unlock_button); + + if (plug->priv->auth_username_label != NULL) + { + expand_string_for_label (plug->priv->auth_username_label); + } + + if (plug->priv->auth_realname_label != NULL) + { + expand_string_for_label (plug->priv->auth_realname_label); + } + + if (! plug->priv->logout_enabled || ! plug->priv->logout_command) + { + if (plug->priv->auth_logout_button != NULL) + { + gtk_widget_hide (plug->priv->auth_logout_button); + } + } + + plug->priv->timeout = DIALOG_TIMEOUT_MSEC; + + g_signal_connect (plug, "key_press_event", + G_CALLBACK (entry_key_press), plug); + + /* button press handler used to inhibit popup menu */ + g_signal_connect (plug->priv->auth_prompt_entry, "button_press_event", + G_CALLBACK (entry_button_press), NULL); + gtk_entry_set_activates_default (GTK_ENTRY (plug->priv->auth_prompt_entry), TRUE); + gtk_entry_set_visibility (GTK_ENTRY (plug->priv->auth_prompt_entry), FALSE); + + g_signal_connect (plug->priv->auth_unlock_button, "clicked", + G_CALLBACK (unlock_button_clicked), plug); + + g_signal_connect (plug->priv->auth_cancel_button, "clicked", + G_CALLBACK (cancel_button_clicked), plug); + + if (plug->priv->status_message_label) + { + if (plug->priv->status_message) + { + gtk_label_set_text (GTK_LABEL (plug->priv->status_message_label), + plug->priv->status_message); + } + else + { + gtk_widget_hide (plug->priv->status_message_label); + } + } + + if (plug->priv->auth_switch_button != NULL) + { + g_signal_connect (plug->priv->auth_switch_button, "clicked", + G_CALLBACK (switch_user_button_clicked), plug); + } + + if (plug->priv->auth_note_button != NULL) + { + g_signal_connect (plug->priv->auth_note_button, "clicked", + G_CALLBACK (take_note), plug); + g_signal_connect (plug->priv->note_ok_button, "clicked", + G_CALLBACK (submit_note), plug); + g_signal_connect (plug->priv->note_cancel_button, "clicked", + G_CALLBACK (cancel_note), plug); + } + + if (plug->priv->note_tab_label != NULL) + { + expand_string_for_label (plug->priv->note_tab_label); + } + + if (plug->priv->auth_logout_button != NULL) + { + g_signal_connect (plug->priv->auth_logout_button, "clicked", + G_CALLBACK (logout_button_clicked), plug); + } + + g_signal_connect (plug, "delete_event", G_CALLBACK (delete_handler), NULL); + + gs_profile_end (NULL); +} + +static void +gs_lock_plug_finalize (GObject *object) +{ + GSLockPlug *plug; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_LOCK_PLUG (object)); + + plug = GS_LOCK_PLUG (object); + + g_return_if_fail (plug->priv != NULL); + + g_free (plug->priv->logout_command); + + remove_response_idle (plug); + remove_cancel_timeout (plug); + + G_OBJECT_CLASS (gs_lock_plug_parent_class)->finalize (object); +} + +GtkWidget * +gs_lock_plug_new (void) +{ + GtkWidget *result; + + result = g_object_new (GS_TYPE_LOCK_PLUG, NULL); + + gtk_window_set_focus_on_map (GTK_WINDOW (result), TRUE); + + return result; +} diff --git a/src/gs-lock-plug.c.orig b/src/gs-lock-plug.c.orig new file mode 100644 index 0000000..6b5856c --- /dev/null +++ b/src/gs-lock-plug.c.orig @@ -0,0 +1,2050 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef WITH_KBD_LAYOUT_INDICATOR +#include +#endif + +#ifdef WITH_LIBMATENOTIFY +#include +#endif + +#include "gs-lock-plug.h" + +#include "gs-debug.h" + +#define KEY_LOCK_DIALOG_THEME "/apps/mate-screensaver/lock_dialog_theme" +#define MDM_FLEXISERVER_COMMAND "mdmflexiserver" +#define MDM_FLEXISERVER_ARGS "--startnew Standard" + +/* same as SMS ;) */ +#define NOTE_BUFFER_MAX_CHARS 160 + +enum +{ + AUTH_PAGE = 0, +}; + +#define FACE_ICON_SIZE 48 +#define DIALOG_TIMEOUT_MSEC 60000 + +static void gs_lock_plug_finalize (GObject *object); + +#define GS_LOCK_PLUG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_LOCK_PLUG, GSLockPlugPrivate)) + +struct GSLockPlugPrivate +{ + GtkWidget *vbox; + GtkWidget *auth_action_area; + + GtkWidget *notebook; + GtkWidget *auth_face_image; + GtkWidget *auth_realname_label; + GtkWidget *auth_username_label; + GtkWidget *auth_prompt_label; + GtkWidget *auth_prompt_entry; + GtkWidget *auth_prompt_box; + GtkWidget *auth_capslock_label; + GtkWidget *auth_message_label; + GtkWidget *status_message_label; + + GtkWidget *auth_unlock_button; + GtkWidget *auth_switch_button; + GtkWidget *auth_cancel_button; + GtkWidget *auth_logout_button; + GtkWidget *auth_note_button; + GtkWidget *note_tab; + GtkWidget *note_tab_label; + GtkWidget *note_text_view; + GtkWidget *note_ok_button; + GtkWidget *note_cancel_button; + + GtkWidget *auth_prompt_kbd_layout_indicator; + + gboolean caps_lock_on; + gboolean switch_enabled; + gboolean leave_note_enabled; + gboolean logout_enabled; + char *logout_command; + char *status_message; + + guint timeout; + + guint cancel_timeout_id; + guint auth_check_idle_id; + guint response_idle_id; + + GList *key_events; +}; + +typedef struct _ResponseData ResponseData; + +struct _ResponseData +{ + gint response_id; +}; + + +enum +{ + RESPONSE, + CLOSE, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_LOGOUT_ENABLED, + PROP_LOGOUT_COMMAND, + PROP_SWITCH_ENABLED, + PROP_STATUS_MESSAGE +}; + +static guint lock_plug_signals [LAST_SIGNAL]; + +G_DEFINE_TYPE (GSLockPlug, gs_lock_plug, GTK_TYPE_PLUG) + +static void +gs_lock_plug_style_set (GtkWidget *widget, + GtkStyle *previous_style) +{ + GSLockPlug *plug; + + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->style_set) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->style_set (widget, previous_style); + } + + plug = GS_LOCK_PLUG (widget); + + if (! plug->priv->vbox) + { + return; + } + + gtk_container_set_border_width (GTK_CONTAINER (plug->priv->vbox), 12); + gtk_box_set_spacing (GTK_BOX (plug->priv->vbox), 12); + + gtk_container_set_border_width (GTK_CONTAINER (plug->priv->auth_action_area), 0); + gtk_box_set_spacing (GTK_BOX (plug->priv->auth_action_area), 5); +} + +static void +do_user_switch (GSLockPlug *plug) +{ + GError *error; + gboolean res; + char *command; + + command = g_strdup_printf ("%s %s", + MDM_FLEXISERVER_COMMAND, + MDM_FLEXISERVER_ARGS); + + error = NULL; + res = gdk_spawn_command_line_on_screen (gdk_screen_get_default (), + command, + &error); + + g_free (command); + + if (! res) + { + gs_debug ("Unable to start MDM greeter: %s", error->message); + g_error_free (error); + } +} + +static void +set_status_text (GSLockPlug *plug, + const char *text) +{ + if (plug->priv->auth_message_label != NULL) + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_message_label), text); + } +} + +void +gs_lock_plug_set_sensitive (GSLockPlug *plug, + gboolean sensitive) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, sensitive); + gtk_widget_set_sensitive (plug->priv->auth_action_area, sensitive); +} + +static void +remove_cancel_timeout (GSLockPlug *plug) +{ + if (plug->priv->cancel_timeout_id > 0) + { + g_source_remove (plug->priv->cancel_timeout_id); + plug->priv->cancel_timeout_id = 0; + } +} + +static void +remove_response_idle (GSLockPlug *plug) +{ + if (plug->priv->response_idle_id > 0) + { + g_source_remove (plug->priv->response_idle_id); + plug->priv->response_idle_id = 0; + } +} + +static void +gs_lock_plug_response (GSLockPlug *plug, + gint response_id) +{ + int new_response; + + new_response = response_id; + + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + /* Act only on response IDs we recognize */ + if (!(response_id == GS_LOCK_PLUG_RESPONSE_OK + || response_id == GS_LOCK_PLUG_RESPONSE_CANCEL)) + { + return; + } + + remove_cancel_timeout (plug); + remove_response_idle (plug); + + if (response_id == GS_LOCK_PLUG_RESPONSE_CANCEL) + { + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), ""); + } + + g_signal_emit (plug, + lock_plug_signals [RESPONSE], + 0, + new_response); +} + +static gboolean +response_cancel_idle_cb (GSLockPlug *plug) +{ + plug->priv->response_idle_id = 0; + + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); + + return FALSE; +} + +static gboolean +dialog_timed_out (GSLockPlug *plug) +{ + gs_lock_plug_set_sensitive (plug, FALSE); + set_status_text (plug, _("Time has expired.")); + + if (plug->priv->response_idle_id != 0) + { + g_warning ("Response idle ID already set but shouldn't be"); + } + + remove_response_idle (plug); + + plug->priv->response_idle_id = g_timeout_add (2000, + (GSourceFunc)response_cancel_idle_cb, + plug); + return FALSE; +} + + +static void +capslock_update (GSLockPlug *plug, + gboolean is_on) +{ + + plug->priv->caps_lock_on = is_on; + + if (plug->priv->auth_capslock_label == NULL) + { + return; + } + + if (is_on) + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_capslock_label), + _("You have the Caps Lock key on.")); + } + else + { + gtk_label_set_text (GTK_LABEL (plug->priv->auth_capslock_label), + ""); + } +} + +static gboolean +is_capslock_on (void) +{ + XkbStateRec states; + Display *dsp; + + dsp = GDK_DISPLAY (); + if (XkbGetState (dsp, XkbUseCoreKbd, &states) != Success) + { + return FALSE; + } + + return (states.locked_mods & LockMask) != 0; +} + +static void +restart_cancel_timeout (GSLockPlug *plug) +{ + remove_cancel_timeout (plug); + + plug->priv->cancel_timeout_id = g_timeout_add (plug->priv->timeout, + (GSourceFunc)dialog_timed_out, + plug); +} + +void +gs_lock_plug_get_text (GSLockPlug *plug, + char **text) +{ + const char *typed_text; + char *null_text; + char *local_text; + + typed_text = gtk_entry_get_text (GTK_ENTRY (plug->priv->auth_prompt_entry)); + local_text = g_locale_from_utf8 (typed_text, strlen (typed_text), NULL, NULL, NULL); + + null_text = g_strnfill (strlen (typed_text) + 1, '\b'); + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), null_text); + gtk_entry_set_text (GTK_ENTRY (plug->priv->auth_prompt_entry), ""); + g_free (null_text); + + if (text != NULL) + { + *text = local_text; + } +} + +typedef struct +{ + GSLockPlug *plug; + gint response_id; + GMainLoop *loop; + gboolean destroyed; +} RunInfo; + +static void +shutdown_loop (RunInfo *ri) +{ + if (g_main_loop_is_running (ri->loop)) + g_main_loop_quit (ri->loop); +} + +static void +run_unmap_handler (GSLockPlug *plug, + gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); +} + +static void +run_response_handler (GSLockPlug *plug, + gint response_id, + gpointer data) +{ + RunInfo *ri; + + ri = data; + + ri->response_id = response_id; + + shutdown_loop (ri); +} + +static gint +run_delete_handler (GSLockPlug *plug, + GdkEventAny *event, + gpointer data) +{ + RunInfo *ri = data; + + shutdown_loop (ri); + + return TRUE; /* Do not destroy */ +} + +static void +run_destroy_handler (GSLockPlug *plug, + gpointer data) +{ + RunInfo *ri = data; + + /* shutdown_loop will be called by run_unmap_handler */ + ri->destroyed = TRUE; +} + +/* adapted from GTK+ gtkdialog.c */ +int +gs_lock_plug_run (GSLockPlug *plug) +{ + RunInfo ri = { NULL, GTK_RESPONSE_NONE, NULL, FALSE }; + gboolean was_modal; + gulong response_handler; + gulong unmap_handler; + gulong destroy_handler; + gulong delete_handler; + + g_return_val_if_fail (GS_IS_LOCK_PLUG (plug), -1); + + g_object_ref (plug); + + was_modal = GTK_WINDOW (plug)->modal; + if (!was_modal) + { + gtk_window_set_modal (GTK_WINDOW (plug), TRUE); + } + + if (!GTK_WIDGET_VISIBLE (plug)) + { + gtk_widget_show (GTK_WIDGET (plug)); + } + + response_handler = + g_signal_connect (plug, + "response", + G_CALLBACK (run_response_handler), + &ri); + + unmap_handler = + g_signal_connect (plug, + "unmap", + G_CALLBACK (run_unmap_handler), + &ri); + + delete_handler = + g_signal_connect (plug, + "delete_event", + G_CALLBACK (run_delete_handler), + &ri); + + destroy_handler = + g_signal_connect (plug, + "destroy", + G_CALLBACK (run_destroy_handler), + &ri); + + ri.loop = g_main_loop_new (NULL, FALSE); + + GDK_THREADS_LEAVE (); + g_main_loop_run (ri.loop); + GDK_THREADS_ENTER (); + + g_main_loop_unref (ri.loop); + + ri.loop = NULL; + + if (!ri.destroyed) + { + if (! was_modal) + { + gtk_window_set_modal (GTK_WINDOW (plug), FALSE); + } + + g_signal_handler_disconnect (plug, response_handler); + g_signal_handler_disconnect (plug, unmap_handler); + g_signal_handler_disconnect (plug, delete_handler); + g_signal_handler_disconnect (plug, destroy_handler); + } + + g_object_unref (plug); + + return ri.response_id; +} + + +static cairo_surface_t * +surface_from_pixbuf (GdkPixbuf *pixbuf) +{ + cairo_surface_t *surface; + cairo_t *cr; + + surface = cairo_image_surface_create (gdk_pixbuf_get_has_alpha (pixbuf) ? + CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24, + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf)); + cr = cairo_create (surface); + gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); + cairo_paint (cr); + cairo_destroy (cr); + + return surface; +} + +static void +rounded_rectangle (cairo_t *cr, + gdouble aspect, + gdouble x, + gdouble y, + gdouble corner_radius, + gdouble width, + gdouble height) +{ + gdouble radius; + gdouble degrees; + + radius = corner_radius / aspect; + degrees = G_PI / 180.0; + + cairo_new_sub_path (cr); + cairo_arc (cr, + x + width - radius, + y + radius, + radius, + -90 * degrees, + 0 * degrees); + cairo_arc (cr, + x + width - radius, + y + height - radius, + radius, + 0 * degrees, + 90 * degrees); + cairo_arc (cr, + x + radius, + y + height - radius, + radius, + 90 * degrees, + 180 * degrees); + cairo_arc (cr, + x + radius, + y + radius, + radius, + 180 * degrees, + 270 * degrees); + cairo_close_path (cr); +} + +static void +image_set_from_pixbuf (GtkImage *image, + GdkPixbuf *source) +{ + cairo_t *cr; + cairo_t *cr_mask; + cairo_surface_t *surface; + GdkPixmap *pixmap; + GdkPixmap *bitmask; + int w; + int h; + int frame_width; + double radius; + GdkColor color; + double r; + double g; + double b; + + frame_width = 5; + + w = gdk_pixbuf_get_width (source) + frame_width * 2; + h = gdk_pixbuf_get_height (source) + frame_width * 2; + + radius = w / 10; + + pixmap = gdk_pixmap_new (GTK_WIDGET (image)->window, w, h, -1); + bitmask = gdk_pixmap_new (GTK_WIDGET (image)->window, w, h, 1); + + cr = gdk_cairo_create (pixmap); + cr_mask = gdk_cairo_create (bitmask); + + /* setup mask */ + cairo_rectangle (cr_mask, 0, 0, w, h); + cairo_set_operator (cr_mask, CAIRO_OPERATOR_CLEAR); + cairo_fill (cr_mask); + + rounded_rectangle (cr_mask, 1.0, 0.5, 0.5, radius, w - 1, h - 1); + cairo_set_operator (cr_mask, CAIRO_OPERATOR_OVER); + cairo_set_source_rgb (cr_mask, 1, 1, 1); + cairo_fill (cr_mask); + + color = GTK_WIDGET (image)->style->bg [GTK_STATE_NORMAL]; + r = (float)color.red / 65535.0; + g = (float)color.green / 65535.0; + b = (float)color.blue / 65535.0; + + /* set up image */ + cairo_rectangle (cr, 0, 0, w, h); + cairo_set_source_rgb (cr, r, g, b); + cairo_fill (cr); + + rounded_rectangle (cr, + 1.0, + frame_width + 0.5, + frame_width + 0.5, + radius, + w - frame_width * 2 - 1, + h - frame_width * 2 - 1); + cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 0.3); + cairo_fill_preserve (cr); + + surface = surface_from_pixbuf (source); + cairo_set_source_surface (cr, surface, frame_width, frame_width); + cairo_fill (cr); + + gtk_image_set_from_pixmap (image, pixmap, bitmask); + + cairo_surface_destroy (surface); + + g_object_unref (bitmask); + g_object_unref (pixmap); + + cairo_destroy (cr_mask); + cairo_destroy (cr); +} + + +static gboolean +check_user_file (const gchar *filename, + uid_t user, + gssize max_file_size, + gboolean relax_group, + gboolean relax_other) +{ + struct stat fileinfo; + + if (max_file_size < 0) + { + max_file_size = G_MAXSIZE; + } + + /* Exists/Readable? */ + if (g_stat (filename, &fileinfo) < 0) + { + return FALSE; + } + + /* Is a regular file */ + if (G_UNLIKELY (!S_ISREG (fileinfo.st_mode))) + { + return FALSE; + } + + /* Owned by user? */ + if (G_UNLIKELY (fileinfo.st_uid != user)) + { + return FALSE; + } + + /* Group not writable or relax_group? */ + if (G_UNLIKELY ((fileinfo.st_mode & S_IWGRP) == S_IWGRP && !relax_group)) + { + return FALSE; + } + + /* Other not writable or relax_other? */ + if (G_UNLIKELY ((fileinfo.st_mode & S_IWOTH) == S_IWOTH && !relax_other)) + { + return FALSE; + } + + /* Size is kosher? */ + if (G_UNLIKELY (fileinfo.st_size > max_file_size)) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +set_face_image (GSLockPlug *plug) +{ + GdkPixbuf *pixbuf; + const char *homedir; + char *path; + int icon_size = 96; + gsize user_max_file = 65536; + uid_t uid; + + homedir = g_get_home_dir (); + uid = getuid (); + + path = g_build_filename (homedir, ".face", NULL); + + pixbuf = NULL; + if (check_user_file (path, uid, user_max_file, 0, 0)) + { + pixbuf = gdk_pixbuf_new_from_file_at_size (path, + icon_size, + icon_size, + NULL); + } + + g_free (path); + + if (pixbuf == NULL) + { + return FALSE; + } + + image_set_from_pixbuf (GTK_IMAGE (plug->priv->auth_face_image), pixbuf); + + g_object_unref (pixbuf); + + return TRUE; +} + +static void +gs_lock_plug_show (GtkWidget *widget) +{ + GSLockPlug *plug = GS_LOCK_PLUG (widget); + + gs_profile_start (NULL); + + gs_profile_start ("parent"); + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->show) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->show (widget); + } + + gs_profile_end ("parent"); + + + if (plug->priv->auth_face_image) + { + set_face_image (plug); + } + + capslock_update (plug, is_capslock_on ()); + + restart_cancel_timeout (plug); + + gs_profile_end (NULL); +} + +static void +gs_lock_plug_hide (GtkWidget *widget) +{ + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->hide) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->hide (widget); + } +} + +static void +queue_key_event (GSLockPlug *plug, + GdkEventKey *event) +{ + GdkEvent *saved_event; + + saved_event = gdk_event_copy ((GdkEvent *)event); + plug->priv->key_events = g_list_prepend (plug->priv->key_events, + saved_event); +} + +static void +forward_key_events (GSLockPlug *plug) +{ + plug->priv->key_events = g_list_reverse (plug->priv->key_events); + while (plug->priv->key_events != NULL) + { + GdkEventKey *event = plug->priv->key_events->data; + + gtk_window_propagate_key_event (GTK_WINDOW (plug), event); + + gdk_event_free ((GdkEvent *)event); + + plug->priv->key_events = g_list_delete_link (plug->priv->key_events, + plug->priv->key_events); + } +} + +static void +gs_lock_plug_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GSLockPlug *plug = GS_LOCK_PLUG (widget); + int mod_width; + int mod_height; + + if (GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->size_request) + { + GTK_WIDGET_CLASS (gs_lock_plug_parent_class)->size_request (widget, requisition); + } + + /* don't constrain size when themed */ + if (plug->priv->vbox == NULL) + { + return; + } + + mod_width = requisition->height * 1.3; + mod_height = requisition->width / 1.6; + if (requisition->width < mod_width) + { + /* if the dialog is tall fill out the width */ + requisition->width = mod_width; + } + else if (requisition->height < mod_height) + { + /* if the dialog is wide fill out the height */ + requisition->height = mod_height; + } +} + +static void +gs_lock_plug_set_logout_enabled (GSLockPlug *plug, + gboolean logout_enabled) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + if (plug->priv->logout_enabled == logout_enabled) + { + return; + } + + plug->priv->logout_enabled = logout_enabled; + g_object_notify (G_OBJECT (plug), "logout-enabled"); + + if (plug->priv->auth_logout_button == NULL) + { + return; + } + + if (logout_enabled) + { + gtk_widget_show (plug->priv->auth_logout_button); + } + else + { + gtk_widget_hide (plug->priv->auth_logout_button); + } +} + +static void +gs_lock_plug_set_logout_command (GSLockPlug *plug, + const char *command) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + g_free (plug->priv->logout_command); + + if (command) + { + plug->priv->logout_command = g_strdup (command); + } + else + { + plug->priv->logout_command = NULL; + } +} + +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 +gs_lock_plug_set_status_message (GSLockPlug *plug, + const char *status_message) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + g_free (plug->priv->status_message); + plug->priv->status_message = g_strdup (status_message); + + if (plug->priv->status_message_label) + { + if (plug->priv->status_message) + { + gtk_label_set_text (GTK_LABEL (plug->priv->status_message_label), + plug->priv->status_message); + gtk_widget_show (plug->priv->status_message_label); + } + else + { + gtk_widget_hide (plug->priv->status_message_label); + } + } +} + +static void +gs_lock_plug_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSLockPlug *self; + + self = GS_LOCK_PLUG (object); + + switch (prop_id) + { + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_SWITCH_ENABLED: + g_value_set_boolean (value, self->priv->switch_enabled); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_lock_plug_set_switch_enabled (GSLockPlug *plug, + gboolean switch_enabled) +{ + g_return_if_fail (GS_LOCK_PLUG (plug)); + + if (plug->priv->switch_enabled == switch_enabled) + { + return; + } + + plug->priv->switch_enabled = switch_enabled; + g_object_notify (G_OBJECT (plug), "switch-enabled"); + + if (plug->priv->auth_switch_button == NULL) + { + return; + } + + if (switch_enabled) + { + gboolean found; + found = is_program_in_path (MDM_FLEXISERVER_COMMAND); + if (found) + { + gtk_widget_show (plug->priv->auth_switch_button); + } + else + { + gs_debug ("Waring: MDM flexiserver command not found: %s", MDM_FLEXISERVER_COMMAND); + gtk_widget_hide (plug->priv->auth_switch_button); + } + } + else + { + gtk_widget_hide (plug->priv->auth_switch_button); + } +} + +static void +gs_lock_plug_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSLockPlug *self; + + self = GS_LOCK_PLUG (object); + + switch (prop_id) + { + case PROP_LOGOUT_ENABLED: + gs_lock_plug_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_lock_plug_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_lock_plug_set_status_message (self, g_value_get_string (value)); + break; + case PROP_SWITCH_ENABLED: + gs_lock_plug_set_switch_enabled (self, g_value_get_boolean (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_lock_plug_close (GSLockPlug *plug) +{ + /* Synthesize delete_event to close dialog. */ + + GtkWidget *widget = GTK_WIDGET (plug); + GdkEvent *event; + + event = gdk_event_new (GDK_DELETE); + event->any.window = g_object_ref (widget->window); + event->any.send_event = TRUE; + + gtk_main_do_event (event); + gdk_event_free (event); +} + +static void +gs_lock_plug_class_init (GSLockPlugClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GtkBindingSet *binding_set; + + object_class->finalize = gs_lock_plug_finalize; + object_class->get_property = gs_lock_plug_get_property; + object_class->set_property = gs_lock_plug_set_property; + + widget_class->style_set = gs_lock_plug_style_set; + widget_class->show = gs_lock_plug_show; + widget_class->hide = gs_lock_plug_hide; + widget_class->size_request = gs_lock_plug_size_request; + + klass->close = gs_lock_plug_close; + + g_type_class_add_private (klass, sizeof (GSLockPlugPrivate)); + + lock_plug_signals [RESPONSE] = g_signal_new ("response", + G_OBJECT_CLASS_TYPE (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSLockPlugClass, response), + NULL, NULL, + g_cclosure_marshal_VOID__INT, + G_TYPE_NONE, 1, + G_TYPE_INT); + lock_plug_signals [CLOSE] = g_signal_new ("close", + G_OBJECT_CLASS_TYPE (klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GSLockPlugClass, close), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_SWITCH_ENABLED, + g_param_spec_boolean ("switch-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + + binding_set = gtk_binding_set_by_class (klass); + + gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0, + "close", 0); +} + +static void +clear_clipboards (GSLockPlug *plug) +{ + GtkClipboard *clipboard; + + clipboard = gtk_widget_get_clipboard (GTK_WIDGET (plug), GDK_SELECTION_PRIMARY); + gtk_clipboard_clear (clipboard); + gtk_clipboard_set_text (clipboard, "", -1); + clipboard = gtk_widget_get_clipboard (GTK_WIDGET (plug), GDK_SELECTION_CLIPBOARD); + gtk_clipboard_clear (clipboard); + gtk_clipboard_set_text (clipboard, "", -1); +} + +static void +take_note (GtkButton *button, + GSLockPlug *plug) +{ + int page; + + page = gtk_notebook_page_num (GTK_NOTEBOOK (plug->priv->notebook), plug->priv->note_tab); + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), page); + /* this counts as activity so restart the timer */ + restart_cancel_timeout (plug); +} + +static void +submit_note (GtkButton *button, + GSLockPlug *plug) +{ +#ifdef WITH_LIBMATENOTIFY + char *text; + char summary[128]; + char *escaped_text; + GtkTextBuffer *buffer; + GtkTextIter start, end; + time_t t; + struct tm *tmp; + NotifyNotification *note; + + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), AUTH_PAGE); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); + gtk_text_buffer_set_text (buffer, "", 0); + escaped_text = g_markup_escape_text (text, -1); + + t = time (NULL); + tmp = localtime (&t); + strftime (summary, 128, "%X", tmp); + + notify_init ("mate-screensaver-dialog"); + note = notify_notification_new (summary, escaped_text, NULL, NULL); + notify_notification_set_timeout (note, NOTIFY_EXPIRES_NEVER); + notify_notification_show (note, NULL); + g_object_unref (note); + + g_free (text); + g_free (escaped_text); + + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); +#endif /* WITH_LIBMATENOTIFY */ +} + +static void +cancel_note (GtkButton *button, + GSLockPlug *plug) +{ + GtkTextBuffer *buffer; + + gtk_notebook_set_current_page (GTK_NOTEBOOK (plug->priv->notebook), AUTH_PAGE); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + gtk_text_buffer_set_text (buffer, "", 0); + + /* this counts as activity so restart the timer */ + restart_cancel_timeout (plug); + + gtk_window_set_default (GTK_WINDOW (plug), plug->priv->auth_unlock_button); + + clear_clipboards (plug); +} + +static void +logout_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + char **argv = NULL; + GError *error = NULL; + gboolean res; + + if (! plug->priv->logout_command) + { + return; + } + + res = g_shell_parse_argv (plug->priv->logout_command, NULL, &argv, &error); + + if (! res) + { + g_warning ("Could not parse logout command: %s", error->message); + g_error_free (error); + return; + } + + g_spawn_async (g_get_home_dir (), + argv, + NULL, + G_SPAWN_SEARCH_PATH, + NULL, + NULL, + NULL, + &error); + + g_strfreev (argv); + + if (error) + { + g_warning ("Could not run logout command: %s", error->message); + g_error_free (error); + } +} + +void +gs_lock_plug_set_busy (GSLockPlug *plug) +{ + GdkCursor *cursor; + GtkWidget *top_level; + + top_level = gtk_widget_get_toplevel (GTK_WIDGET (plug)); + + cursor = gdk_cursor_new (GDK_WATCH); + gdk_window_set_cursor (top_level->window, cursor); + gdk_cursor_unref (cursor); +} + +void +gs_lock_plug_set_ready (GSLockPlug *plug) +{ + GdkCursor *cursor; + GtkWidget *top_level; + + top_level = gtk_widget_get_toplevel (GTK_WIDGET (plug)); + + cursor = gdk_cursor_new (GDK_LEFT_PTR); + gdk_window_set_cursor (top_level->window, cursor); + gdk_cursor_unref (cursor); +} + +void +gs_lock_plug_enable_prompt (GSLockPlug *plug, + const char *message, + gboolean visible) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + gs_debug ("Setting prompt to: %s", message); + + gtk_widget_set_sensitive (plug->priv->auth_unlock_button, TRUE); + gtk_widget_show (plug->priv->auth_unlock_button); + gtk_widget_grab_default (plug->priv->auth_unlock_button); + gtk_label_set_text (GTK_LABEL (plug->priv->auth_prompt_label), message); + gtk_widget_show (plug->priv->auth_prompt_label); + gtk_entry_set_visibility (GTK_ENTRY (plug->priv->auth_prompt_entry), visible); + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, TRUE); + gtk_widget_show (plug->priv->auth_prompt_entry); + + if (! GTK_WIDGET_HAS_FOCUS (plug->priv->auth_prompt_entry)) + { + gtk_widget_grab_focus (plug->priv->auth_prompt_entry); + } + + /* were there any key events sent to the plug while the + * entry wasnt ready? If so, forward them along + */ + forward_key_events (plug); + + restart_cancel_timeout (plug); +} + +void +gs_lock_plug_disable_prompt (GSLockPlug *plug) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + /* gtk_widget_hide (plug->priv->auth_prompt_entry); */ + /* gtk_widget_hide (plug->priv->auth_prompt_label); */ + gtk_widget_set_sensitive (plug->priv->auth_unlock_button, FALSE); + gtk_widget_set_sensitive (plug->priv->auth_prompt_entry, FALSE); + /* gtk_widget_hide (plug->priv->auth_unlock_button); */ + + gtk_widget_grab_default (plug->priv->auth_cancel_button); +} + +void +gs_lock_plug_show_message (GSLockPlug *plug, + const char *message) +{ + g_return_if_fail (GS_IS_LOCK_PLUG (plug)); + + set_status_text (plug, message ? message : ""); +} + +/* button press handler used to inhibit popup menu */ +static gint +entry_button_press (GtkWidget *widget, + GdkEventButton *event) +{ + if (event->button == 3 && event->type == GDK_BUTTON_PRESS) + { + return TRUE; + } + + return FALSE; +} + +static gint +entry_key_press (GtkWidget *widget, + GdkEventKey *event, + GSLockPlug *plug) +{ + gboolean capslock_on; + + restart_cancel_timeout (plug); + + capslock_on = is_capslock_on (); + + if (capslock_on != plug->priv->caps_lock_on) + { + capslock_update (plug, capslock_on); + } + + /* if the input widget is visible and ready for input + * then just carry on as usual + */ + if (GTK_WIDGET_VISIBLE (plug->priv->auth_prompt_entry) && + GTK_WIDGET_IS_SENSITIVE (plug->priv->auth_prompt_entry)) + { + return FALSE; + } + + if (strcmp (event->string, "") == 0) + { + return FALSE; + } + + queue_key_event (plug, event); + + return TRUE; +} + +/* adapted from gtk_dialog_add_button */ +static GtkWidget * +gs_lock_plug_add_button (GSLockPlug *plug, + GtkWidget *action_area, + const gchar *button_text) +{ + GtkWidget *button; + + g_return_val_if_fail (GS_IS_LOCK_PLUG (plug), NULL); + g_return_val_if_fail (button_text != NULL, NULL); + + button = gtk_button_new_from_stock (button_text); + + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + + gtk_widget_show (button); + + gtk_box_pack_end (GTK_BOX (action_area), + button, + FALSE, TRUE, 0); + + return button; +} + +static char * +get_user_display_name (void) +{ + const char *name; + char *utf8_name; + + name = g_get_real_name (); + + if (name == NULL || strcmp (name, "Unknown") == 0) + { + name = g_get_user_name (); + } + + utf8_name = NULL; + + if (name != NULL) + { + utf8_name = g_locale_to_utf8 (name, -1, NULL, NULL, NULL); + } + + return utf8_name; +} + +static char * +get_user_name (void) +{ + const char *name; + char *utf8_name; + + name = g_get_user_name (); + + utf8_name = NULL; + if (name != NULL) + { + utf8_name = g_locale_to_utf8 (name, -1, NULL, NULL, NULL); + } + + return utf8_name; +} + +static void +create_page_one_buttons (GSLockPlug *plug) +{ + + gs_profile_start ("page one buttons"); + + plug->priv->auth_switch_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("S_witch User...")); + gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (plug->priv->auth_action_area), + plug->priv->auth_switch_button, + TRUE); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_switch_button), FALSE); + gtk_widget_set_no_show_all (plug->priv->auth_switch_button, TRUE); + + plug->priv->auth_logout_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("Log _Out")); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_logout_button), FALSE); + gtk_widget_set_no_show_all (plug->priv->auth_logout_button, TRUE); + + plug->priv->auth_cancel_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + GTK_STOCK_CANCEL); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_cancel_button), FALSE); + + plug->priv->auth_unlock_button = gs_lock_plug_add_button (GS_LOCK_PLUG (plug), + plug->priv->auth_action_area, + _("_Unlock")); + gtk_button_set_focus_on_click (GTK_BUTTON (plug->priv->auth_unlock_button), FALSE); + + gtk_window_set_default (GTK_WINDOW (plug), plug->priv->auth_unlock_button); + + gs_profile_end ("page one buttons"); +} + +/* adapted from MDM */ +static char * +expand_string (const char *text) +{ + GString *str; + const char *p; + char *username; + int i; + int n_chars; + struct utsname name; + + str = g_string_sized_new (strlen (text)); + + p = text; + n_chars = g_utf8_strlen (text, -1); + i = 0; + + while (i < n_chars) + { + gunichar ch; + + ch = g_utf8_get_char (p); + + /* Backslash commands */ + if (ch == '\\') + { + p = g_utf8_next_char (p); + i++; + ch = g_utf8_get_char (p); + + if (i >= n_chars || ch == '\0') + { + g_warning ("Unescaped \\ at end of text\n"); + goto bail; + } + else if (ch == 'n') + { + g_string_append_unichar (str, '\n'); + } + else + { + g_string_append_unichar (str, ch); + } + } + else if (ch == '%') + { + p = g_utf8_next_char (p); + i++; + ch = g_utf8_get_char (p); + + if (i >= n_chars || ch == '\0') + { + g_warning ("Unescaped %% at end of text\n"); + goto bail; + } + + switch (ch) + { + case '%': + g_string_append (str, "%"); + break; + case 'c': + /* clock */ + break; + case 'd': + /* display */ + g_string_append (str, g_getenv ("DISPLAY")); + break; + case 'h': + /* hostname */ + g_string_append (str, g_get_host_name ()); + break; + case 'm': + /* machine name */ + uname (&name); + g_string_append (str, name.machine); + break; + case 'n': + /* nodename */ + uname (&name); + g_string_append (str, name.nodename); + break; + case 'r': + /* release */ + uname (&name); + g_string_append (str, name.release); + break; + case 'R': + /* Real name */ + username = get_user_display_name (); + g_string_append (str, username); + g_free (username); + break; + case 's': + /* system name */ + uname (&name); + g_string_append (str, name.sysname); + break; + case 'U': + /* Username */ + username = get_user_name (); + g_string_append (str, username); + g_free (username); + break; + default: + if (ch < 127) + { + g_warning ("unknown escape code %%%c in text\n", (char)ch); + } + else + { + g_warning ("unknown escape code %%(U%x) in text\n", (int)ch); + } + } + } + else + { + g_string_append_unichar (str, ch); + } + p = g_utf8_next_char (p); + i++; + } + +bail: + + return g_string_free (str, FALSE); +} + +static void +expand_string_for_label (GtkWidget *label) +{ + const char *template; + char *str; + + template = gtk_label_get_label (GTK_LABEL (label)); + str = expand_string (template); + gtk_label_set_label (GTK_LABEL (label), str); + g_free (str); +} + +static void +create_page_one (GSLockPlug *plug) +{ + GtkWidget *align; + GtkWidget *vbox; + GtkWidget *vbox2; + GtkWidget *hbox; + char *str; + + gs_profile_start ("page one"); + + align = gtk_alignment_new (0.5, 0.5, 1, 1); + gtk_notebook_append_page (GTK_NOTEBOOK (plug->priv->notebook), align, NULL); + + vbox = gtk_vbox_new (FALSE, 12); + gtk_container_add (GTK_CONTAINER (align), vbox); + + plug->priv->auth_face_image = gtk_image_new (); + gtk_box_pack_start (GTK_BOX (vbox), plug->priv->auth_face_image, TRUE, TRUE, 0); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_face_image), 0.5, 1.0); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); + + str = g_strdup ("%R"); + plug->priv->auth_realname_label = gtk_label_new (str); + g_free (str); + expand_string_for_label (plug->priv->auth_realname_label); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_realname_label), 0.5, 0.5); + gtk_label_set_use_markup (GTK_LABEL (plug->priv->auth_realname_label), TRUE); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_realname_label, FALSE, FALSE, 0); + + /* To translators: This expands to USERNAME on HOSTNAME */ + str = g_strdup_printf ("%s", _("%U on %h")); + plug->priv->auth_username_label = gtk_label_new (str); + g_free (str); + expand_string_for_label (plug->priv->auth_username_label); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_username_label), 0.5, 0.5); + gtk_label_set_use_markup (GTK_LABEL (plug->priv->auth_username_label), TRUE); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_username_label, FALSE, FALSE, 0); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); + + plug->priv->auth_prompt_label = gtk_label_new_with_mnemonic (_("_Password:")); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_prompt_label), 0, 0.5); + gtk_box_pack_start (GTK_BOX (hbox), plug->priv->auth_prompt_label, FALSE, FALSE, 0); + + plug->priv->auth_prompt_entry = gtk_entry_new (); + gtk_box_pack_start (GTK_BOX (hbox), plug->priv->auth_prompt_entry, TRUE, TRUE, 0); + + gtk_label_set_mnemonic_widget (GTK_LABEL (plug->priv->auth_prompt_label), + plug->priv->auth_prompt_entry); + + plug->priv->auth_capslock_label = gtk_label_new (""); + gtk_misc_set_alignment (GTK_MISC (plug->priv->auth_capslock_label), 0.5, 0.5); + gtk_box_pack_start (GTK_BOX (vbox2), plug->priv->auth_capslock_label, FALSE, FALSE, 0); + + /* Status text */ + + plug->priv->auth_message_label = gtk_label_new (NULL); + gtk_box_pack_start (GTK_BOX (vbox), plug->priv->auth_message_label, + FALSE, FALSE, 0); + /* Buttons */ + plug->priv->auth_action_area = gtk_hbutton_box_new (); + + gtk_button_box_set_layout (GTK_BUTTON_BOX (plug->priv->auth_action_area), + GTK_BUTTONBOX_END); + + gtk_box_pack_end (GTK_BOX (vbox), plug->priv->auth_action_area, + FALSE, TRUE, 0); + gtk_widget_show (plug->priv->auth_action_area); + + create_page_one_buttons (plug); + + gs_profile_end ("page one"); +} + +static void +unlock_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_OK); +} + +static void +cancel_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); +} + +static void +switch_user_button_clicked (GtkButton *button, + GSLockPlug *plug) +{ + + remove_response_idle (plug); + + gs_lock_plug_set_sensitive (plug, FALSE); + + plug->priv->response_idle_id = g_timeout_add (2000, + (GSourceFunc)response_cancel_idle_cb, + plug); + + gs_lock_plug_set_busy (plug); + do_user_switch (plug); +} + +static char * +get_dialog_theme_name (GSLockPlug *plug) +{ + char *name; + MateConfClient *client; + + client = mateconf_client_get_default (); + name = mateconf_client_get_string (client, KEY_LOCK_DIALOG_THEME, NULL); + g_object_unref (client); + + return name; +} + +static gboolean +load_theme (GSLockPlug *plug) +{ + char *theme; + char *filename; + char *gtkbuilder; + char *rc; + GtkBuilder *builder; + GtkWidget *lock_dialog; + GError *error=NULL; + + theme = get_dialog_theme_name (plug); + if (theme == NULL) + { + return FALSE; + } + + filename = g_strdup_printf ("lock-dialog-%s.ui", theme); + gtkbuilder = g_build_filename (GTKBUILDERDIR, filename, NULL); + g_free (filename); + if (! g_file_test (gtkbuilder, G_FILE_TEST_IS_REGULAR)) + { + g_free (gtkbuilder); + g_free (theme); + return FALSE; + } + + filename = g_strdup_printf ("lock-dialog-%s.gtkrc", theme); + g_free (theme); + + rc = g_build_filename (GTKBUILDERDIR, filename, NULL); + g_free (filename); + if (g_file_test (rc, G_FILE_TEST_IS_REGULAR)) + { + gtk_rc_parse (rc); + } + g_free (rc); + + builder = gtk_builder_new(); + + if (!gtk_builder_add_from_file (builder,gtkbuilder,&error)) + { + g_warning ("Couldn't load builder file '%s': %s", gtkbuilder, error->message); + g_error_free(error); + g_free (gtkbuilder); + return FALSE; + } + g_free (gtkbuilder); + + lock_dialog = GTK_WIDGET (gtk_builder_get_object(builder, "lock-dialog")); + gtk_container_add (GTK_CONTAINER (plug), lock_dialog); + + plug->priv->vbox = NULL; + plug->priv->notebook = GTK_WIDGET (gtk_builder_get_object(builder, "notebook")); + + plug->priv->auth_face_image = GTK_WIDGET (gtk_builder_get_object(builder, "auth-face-image")); + plug->priv->auth_action_area = GTK_WIDGET (gtk_builder_get_object(builder, "auth-action-area")); + plug->priv->auth_realname_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-realname-label")); + plug->priv->auth_username_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-username-label")); + plug->priv->auth_prompt_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-label")); + plug->priv->auth_prompt_entry = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-entry")); + plug->priv->auth_prompt_box = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-box")); + plug->priv->auth_capslock_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-capslock-label")); + plug->priv->auth_message_label = GTK_WIDGET (gtk_builder_get_object(builder, "auth-status-label")); + plug->priv->auth_unlock_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-unlock-button")); + plug->priv->auth_cancel_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-cancel-button")); + plug->priv->auth_logout_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-logout-button")); + plug->priv->auth_switch_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-switch-button")); + plug->priv->auth_note_button = GTK_WIDGET (gtk_builder_get_object(builder, "auth-note-button")); + plug->priv->note_tab = GTK_WIDGET (gtk_builder_get_object(builder, "note-tab")); + plug->priv->note_tab_label = GTK_WIDGET (gtk_builder_get_object(builder, "note-tab-label")); + plug->priv->note_ok_button = GTK_WIDGET (gtk_builder_get_object(builder, "note-ok-button")); + plug->priv->note_text_view = GTK_WIDGET (gtk_builder_get_object(builder, "note-text-view")); + plug->priv->note_cancel_button = GTK_WIDGET (gtk_builder_get_object(builder, "note-cancel-button")); + + /* Placeholder for the keyboard indicator */ + plug->priv->auth_prompt_kbd_layout_indicator = GTK_WIDGET (gtk_builder_get_object(builder, "auth-prompt-kbd-layout-indicator")); + if (plug->priv->auth_logout_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_logout_button, TRUE); + } + if (plug->priv->auth_switch_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_switch_button, TRUE); + } + if (plug->priv->auth_note_button != NULL) + { + gtk_widget_set_no_show_all (plug->priv->auth_note_button, TRUE); + } + + gtk_widget_show_all (lock_dialog); + + plug->priv->status_message_label = GTK_WIDGET (gtk_builder_get_object(builder, "status-message-label")); + + return TRUE; +} + +static int +delete_handler (GSLockPlug *plug, + GdkEventAny *event, + gpointer data) +{ + gs_lock_plug_response (plug, GS_LOCK_PLUG_RESPONSE_CANCEL); + + return TRUE; /* Do not destroy */ +} + +static void +on_note_text_buffer_changed (GtkTextBuffer *buffer, + GSLockPlug *plug) +{ + int len; + + len = gtk_text_buffer_get_char_count (buffer); + if (len > NOTE_BUFFER_MAX_CHARS) + { + gtk_widget_set_sensitive (plug->priv->note_text_view, FALSE); + } +} + +static void +gs_lock_plug_init (GSLockPlug *plug) +{ + gs_profile_start (NULL); + + plug->priv = GS_LOCK_PLUG_GET_PRIVATE (plug); + + clear_clipboards (plug); + +#ifdef WITH_LIBMATENOTIFY + plug->priv->leave_note_enabled = TRUE; +#else + plug->priv->leave_note_enabled = FALSE; +#endif + + if (! load_theme (plug)) + { + gs_debug ("Unable to load theme!"); + + plug->priv->vbox = gtk_vbox_new (FALSE, 0); + + gtk_container_add (GTK_CONTAINER (plug), plug->priv->vbox); + + /* Notebook */ + + plug->priv->notebook = gtk_notebook_new (); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (plug->priv->notebook), FALSE); + gtk_notebook_set_show_border (GTK_NOTEBOOK (plug->priv->notebook), FALSE); + gtk_box_pack_start (GTK_BOX (plug->priv->vbox), plug->priv->notebook, TRUE, TRUE, 0); + + /* Page 1 */ + + create_page_one (plug); + + gtk_widget_show_all (plug->priv->vbox); + } + + if (plug->priv->note_text_view != NULL) + { + GtkTextBuffer *buffer; + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (plug->priv->note_text_view)); + g_signal_connect (buffer, "changed", G_CALLBACK (on_note_text_buffer_changed), plug); + } + + /* Layout indicator */ +#ifdef WITH_KBD_LAYOUT_INDICATOR + if (plug->priv->auth_prompt_kbd_layout_indicator != NULL) + { + XklEngine *engine; + + engine = xkl_engine_get_instance (GDK_DISPLAY ()); + if (xkl_engine_get_num_groups (engine) > 1) + { + GtkWidget *layout_indicator; + + layout_indicator = matekbd_indicator_new (); + matekbd_indicator_set_parent_tooltips (MATEKBD_INDICATOR (layout_indicator), TRUE); + gtk_box_pack_start (GTK_BOX (plug->priv->auth_prompt_kbd_layout_indicator), + layout_indicator, + FALSE, + FALSE, + 6); + + gtk_widget_show_all (layout_indicator); + gtk_widget_show (plug->priv->auth_prompt_kbd_layout_indicator); + } + else + { + gtk_widget_hide (plug->priv->auth_prompt_kbd_layout_indicator); + } + + g_object_unref (engine); + } +#endif + + if (plug->priv->auth_note_button != NULL) + { + if (plug->priv->leave_note_enabled) + { + gtk_widget_show_all (plug->priv->auth_note_button); + } + else + { + gtk_widget_hide (plug->priv->auth_note_button); + } + } + if (plug->priv->auth_switch_button != NULL) + { + if (plug->priv->switch_enabled) + { + gtk_widget_show_all (plug->priv->auth_switch_button); + } + else + { + gtk_widget_hide (plug->priv->auth_switch_button); + } + } + + gtk_widget_grab_default (plug->priv->auth_unlock_button); + + if (plug->priv->auth_username_label != NULL) + { + expand_string_for_label (plug->priv->auth_username_label); + } + + if (plug->priv->auth_realname_label != NULL) + { + expand_string_for_label (plug->priv->auth_realname_label); + } + + if (! plug->priv->logout_enabled || ! plug->priv->logout_command) + { + if (plug->priv->auth_logout_button != NULL) + { + gtk_widget_hide (plug->priv->auth_logout_button); + } + } + + plug->priv->timeout = DIALOG_TIMEOUT_MSEC; + + g_signal_connect (plug, "key_press_event", + G_CALLBACK (entry_key_press), plug); + + /* button press handler used to inhibit popup menu */ + g_signal_connect (plug->priv->auth_prompt_entry, "button_press_event", + G_CALLBACK (entry_button_press), NULL); + gtk_entry_set_activates_default (GTK_ENTRY (plug->priv->auth_prompt_entry), TRUE); + gtk_entry_set_visibility (GTK_ENTRY (plug->priv->auth_prompt_entry), FALSE); + + g_signal_connect (plug->priv->auth_unlock_button, "clicked", + G_CALLBACK (unlock_button_clicked), plug); + + g_signal_connect (plug->priv->auth_cancel_button, "clicked", + G_CALLBACK (cancel_button_clicked), plug); + + if (plug->priv->status_message_label) + { + if (plug->priv->status_message) + { + gtk_label_set_text (GTK_LABEL (plug->priv->status_message_label), + plug->priv->status_message); + } + else + { + gtk_widget_hide (plug->priv->status_message_label); + } + } + + if (plug->priv->auth_switch_button != NULL) + { + g_signal_connect (plug->priv->auth_switch_button, "clicked", + G_CALLBACK (switch_user_button_clicked), plug); + } + + if (plug->priv->auth_note_button != NULL) + { + g_signal_connect (plug->priv->auth_note_button, "clicked", + G_CALLBACK (take_note), plug); + g_signal_connect (plug->priv->note_ok_button, "clicked", + G_CALLBACK (submit_note), plug); + g_signal_connect (plug->priv->note_cancel_button, "clicked", + G_CALLBACK (cancel_note), plug); + } + + if (plug->priv->note_tab_label != NULL) + { + expand_string_for_label (plug->priv->note_tab_label); + } + + if (plug->priv->auth_logout_button != NULL) + { + g_signal_connect (plug->priv->auth_logout_button, "clicked", + G_CALLBACK (logout_button_clicked), plug); + } + + g_signal_connect (plug, "delete_event", G_CALLBACK (delete_handler), NULL); + + gs_profile_end (NULL); +} + +static void +gs_lock_plug_finalize (GObject *object) +{ + GSLockPlug *plug; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_LOCK_PLUG (object)); + + plug = GS_LOCK_PLUG (object); + + g_return_if_fail (plug->priv != NULL); + + g_free (plug->priv->logout_command); + + remove_response_idle (plug); + remove_cancel_timeout (plug); + + G_OBJECT_CLASS (gs_lock_plug_parent_class)->finalize (object); +} + +GtkWidget * +gs_lock_plug_new (void) +{ + GtkWidget *result; + + result = g_object_new (GS_TYPE_LOCK_PLUG, NULL); + + gtk_window_set_focus_on_map (GTK_WINDOW (result), TRUE); + + return result; +} diff --git a/src/gs-lock-plug.h b/src/gs-lock-plug.h new file mode 100644 index 0000000..3217bbf --- /dev/null +++ b/src/gs-lock-plug.h @@ -0,0 +1,82 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_LOCK_PLUG_H +#define __GS_LOCK_PLUG_H + +G_BEGIN_DECLS + +typedef enum +{ + GS_LOCK_PLUG_RESPONSE_NONE = -1, + GS_LOCK_PLUG_RESPONSE_OK = -2, + GS_LOCK_PLUG_RESPONSE_CANCEL = -3 +} GSPlugResponseType; + +#define GS_TYPE_LOCK_PLUG (gs_lock_plug_get_type ()) +#define GS_LOCK_PLUG(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_LOCK_PLUG, GSLockPlug)) +#define GS_LOCK_PLUG_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_LOCK_PLUG, GSLockPlugClass)) +#define GS_IS_LOCK_PLUG(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_LOCK_PLUG)) +#define GS_IS_LOCK_PLUG_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_LOCK_PLUG)) +#define GS_LOCK_PLUG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_LOCK_PLUG, GSLockPlugClass)) + +typedef struct GSLockPlugPrivate GSLockPlugPrivate; + +typedef struct +{ + GtkPlug parent; + + GSLockPlugPrivate *priv; +} GSLockPlug; + +typedef struct +{ + GtkPlugClass parent_class; + + void (* response) (GSLockPlug *plug, gint response_id); + + /* Keybinding signals */ + void (* close) (GSLockPlug *plug); + +} GSLockPlugClass; + +GType gs_lock_plug_get_type (void); +GtkWidget * gs_lock_plug_new (void); + +int gs_lock_plug_run (GSLockPlug *plug); +void gs_lock_plug_set_sensitive (GSLockPlug *plug, + gboolean sensitive); +void gs_lock_plug_enable_prompt (GSLockPlug *plug, + const char *message, + gboolean visible); +void gs_lock_plug_disable_prompt (GSLockPlug *plug); +void gs_lock_plug_set_busy (GSLockPlug *plug); +void gs_lock_plug_set_ready (GSLockPlug *plug); + +void gs_lock_plug_get_text (GSLockPlug *plug, + char **text); +void gs_lock_plug_show_message (GSLockPlug *plug, + const char *message); + +G_END_DECLS + +#endif /* __GS_LOCK_PLUG_H */ diff --git a/src/gs-lock-plug.h.orig b/src/gs-lock-plug.h.orig new file mode 100644 index 0000000..cc71f21 --- /dev/null +++ b/src/gs-lock-plug.h.orig @@ -0,0 +1,82 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_LOCK_PLUG_H +#define __GS_LOCK_PLUG_H + +G_BEGIN_DECLS + +typedef enum +{ + GS_LOCK_PLUG_RESPONSE_NONE = -1, + GS_LOCK_PLUG_RESPONSE_OK = -2, + GS_LOCK_PLUG_RESPONSE_CANCEL = -3 +} GSPlugResponseType; + +#define GS_TYPE_LOCK_PLUG (gs_lock_plug_get_type ()) +#define GS_LOCK_PLUG(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_LOCK_PLUG, GSLockPlug)) +#define GS_LOCK_PLUG_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_LOCK_PLUG, GSLockPlugClass)) +#define GS_IS_LOCK_PLUG(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_LOCK_PLUG)) +#define GS_IS_LOCK_PLUG_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_LOCK_PLUG)) +#define GS_LOCK_PLUG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_LOCK_PLUG, GSLockPlugClass)) + +typedef struct GSLockPlugPrivate GSLockPlugPrivate; + +typedef struct +{ + GtkPlug parent; + + GSLockPlugPrivate *priv; +} GSLockPlug; + +typedef struct +{ + GtkPlugClass parent_class; + + void (* response) (GSLockPlug *plug, gint response_id); + + /* Keybinding signals */ + void (* close) (GSLockPlug *plug); + +} GSLockPlugClass; + +GType gs_lock_plug_get_type (void); +GtkWidget * gs_lock_plug_new (void); + +int gs_lock_plug_run (GSLockPlug *plug); +void gs_lock_plug_set_sensitive (GSLockPlug *plug, + gboolean sensitive); +void gs_lock_plug_enable_prompt (GSLockPlug *plug, + const char *message, + gboolean visible); +void gs_lock_plug_disable_prompt (GSLockPlug *plug); +void gs_lock_plug_set_busy (GSLockPlug *plug); +void gs_lock_plug_set_ready (GSLockPlug *plug); + +void gs_lock_plug_get_text (GSLockPlug *plug, + char **text); +void gs_lock_plug_show_message (GSLockPlug *plug, + const char *message); + +G_END_DECLS + +#endif /* __GS_LOCK_PLUG_H */ diff --git a/src/gs-manager.c b/src/gs-manager.c new file mode 100644 index 0000000..3deca22 --- /dev/null +++ b/src/gs-manager.c @@ -0,0 +1,2030 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2008 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include + +#define MATE_DESKTOP_USE_UNSTABLE_API +#include + +#include "gs-prefs.h" /* for GSSaverMode */ + +#include "gs-manager.h" +#include "gs-window.h" +#include "gs-theme-manager.h" +#include "gs-job.h" +#include "gs-grab.h" +#include "gs-fade.h" +#include "gs-debug.h" + +static void gs_manager_class_init (GSManagerClass *klass); +static void gs_manager_init (GSManager *manager); +static void gs_manager_finalize (GObject *object); + +#define GS_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_MANAGER, GSManagerPrivate)) + +struct GSManagerPrivate +{ + GSList *windows; + GHashTable *jobs; + + GSThemeManager *theme_manager; + MateConfClient *client; + MateBG *bg; + guint bg_notify_id; + + /* Policy */ + glong lock_timeout; + glong cycle_timeout; + glong logout_timeout; + + guint lock_enabled : 1; + guint logout_enabled : 1; + guint keyboard_enabled : 1; + guint user_switch_enabled : 1; + guint throttled : 1; + + char *logout_command; + char *keyboard_command; + + char *status_message; + + /* State */ + guint active : 1; + guint lock_active : 1; + + guint fading : 1; + guint dialog_up : 1; + + time_t activate_time; + + guint lock_timeout_id; + guint cycle_timeout_id; + + GSList *themes; + GSSaverMode saver_mode; + GSGrab *grab; + GSFade *fade; + guint unfade_idle_id; +}; + +enum +{ + ACTIVATED, + DEACTIVATED, + AUTH_REQUEST_BEGIN, + AUTH_REQUEST_END, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_LOCK_ENABLED, + PROP_LOGOUT_ENABLED, + PROP_USER_SWITCH_ENABLED, + PROP_KEYBOARD_ENABLED, + PROP_LOCK_TIMEOUT, + PROP_CYCLE_TIMEOUT, + PROP_LOGOUT_TIMEOUT, + PROP_LOGOUT_COMMAND, + PROP_KEYBOARD_COMMAND, + PROP_STATUS_MESSAGE, + PROP_ACTIVE, + PROP_THROTTLED, +}; + +#define FADE_TIMEOUT 1000 + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSManager, gs_manager, G_TYPE_OBJECT) + +static void +manager_add_job_for_window (GSManager *manager, + GSWindow *window, + GSJob *job) +{ + if (manager->priv->jobs == NULL) + { + return; + } + + g_hash_table_insert (manager->priv->jobs, window, job); +} + +static const char * +select_theme (GSManager *manager) +{ + const char *theme = NULL; + + g_return_val_if_fail (manager != NULL, NULL); + g_return_val_if_fail (GS_IS_MANAGER (manager), NULL); + + if (manager->priv->saver_mode == GS_MODE_BLANK_ONLY) + { + return NULL; + } + + if (manager->priv->themes) + { + int number = 0; + + if (manager->priv->saver_mode == GS_MODE_RANDOM) + { + g_random_set_seed (time (NULL)); + number = g_random_int_range (0, g_slist_length (manager->priv->themes)); + } + theme = g_slist_nth_data (manager->priv->themes, number); + } + + return theme; +} + +static GSJob * +lookup_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + if (manager->priv->jobs == NULL) + { + return NULL; + } + + job = g_hash_table_lookup (manager->priv->jobs, window); + + return job; +} + +static void +manager_maybe_stop_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + job = lookup_job_for_window (manager, window); + + if (job == NULL) + { + gs_debug ("Job not found for window"); + return; + } + + gs_job_stop (job); +} + +static void +manager_maybe_start_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + job = lookup_job_for_window (manager, window); + + if (job == NULL) + { + gs_debug ("Job not found for window"); + return; + } + + if (! manager->priv->dialog_up) + { + if (! manager->priv->throttled) + { + if (! gs_job_is_running (job)) + { + if (! gs_window_is_obscured (window)) + { + gs_debug ("Starting job for window"); + gs_job_start (job); + } + else + { + gs_debug ("Window is obscured deferring start of job"); + } + } + else + { + gs_debug ("Not starting job because job is running"); + } + } + else + { + gs_debug ("Not starting job because throttled"); + } + } + else + { + gs_debug ("Not starting job because dialog is up"); + } +} + +static void +manager_select_theme_for_job (GSManager *manager, + GSJob *job) +{ + const char *theme; + + theme = select_theme (manager); + + if (theme != NULL) + { + GSThemeInfo *info; + const char *command; + + command = NULL; + + info = gs_theme_manager_lookup_theme_info (manager->priv->theme_manager, theme); + if (info != NULL) + { + command = gs_theme_info_get_exec (info); + } + else + { + gs_debug ("Could not find information for theme: %s", + theme); + } + + gs_job_set_command (job, command); + + + if (info != NULL) + { + gs_theme_info_unref (info); + } + } + else + { + gs_job_set_command (job, NULL); + } +} + +static void +cycle_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + gs_job_stop (job); + manager_select_theme_for_job (manager, job); + manager_maybe_start_job_for_window (manager, window); +} + +static void +manager_cycle_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) cycle_job, manager); + } +} + +static void +throttle_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + if (manager->priv->throttled) + { + gs_job_stop (job); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +manager_throttle_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) throttle_job, manager); + } +} + +static void +resume_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + if (gs_job_is_running (job)) + { + gs_job_suspend (job, FALSE); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +manager_resume_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) resume_job, manager); + } +} + +static void +suspend_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + gs_job_suspend (job, TRUE); +} + +static void +manager_suspend_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) suspend_job, manager); + } +} + +static void +manager_stop_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_destroy (manager->priv->jobs); + + } + manager->priv->jobs = NULL; +} + +void +gs_manager_set_mode (GSManager *manager, + GSSaverMode mode) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + manager->priv->saver_mode = mode; +} + +static void +free_themes (GSManager *manager) +{ + if (manager->priv->themes) + { + g_slist_foreach (manager->priv->themes, (GFunc)g_free, NULL); + g_slist_free (manager->priv->themes); + } +} + +void +gs_manager_set_themes (GSManager *manager, + GSList *themes) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + free_themes (manager); + manager->priv->themes = NULL; + + for (l = themes; l; l = l->next) + { + manager->priv->themes = g_slist_append (manager->priv->themes, g_strdup (l->data)); + } +} + +void +gs_manager_set_throttled (GSManager *manager, + gboolean throttled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->throttled != throttled) + { + GSList *l; + + manager->priv->throttled = throttled; + + if (! manager->priv->dialog_up) + { + + manager_throttle_jobs (manager); + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_clear (l->data); + } + } + } +} + +void +gs_manager_get_lock_active (GSManager *manager, + gboolean *lock_active) +{ + if (lock_active != NULL) + { + *lock_active = FALSE; + } + + g_return_if_fail (GS_IS_MANAGER (manager)); + + *lock_active = manager->priv->lock_active; +} + +void +gs_manager_set_lock_active (GSManager *manager, + gboolean lock_active) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Setting lock active: %d", lock_active); + + if (manager->priv->lock_active != lock_active) + { + GSList *l; + + manager->priv->lock_active = lock_active; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_lock_enabled (l->data, lock_active); + } + } +} + +void +gs_manager_get_lock_enabled (GSManager *manager, + gboolean *lock_enabled) +{ + if (lock_enabled != NULL) + { + *lock_enabled = FALSE; + } + + g_return_if_fail (GS_IS_MANAGER (manager)); + + *lock_enabled = manager->priv->lock_enabled; +} + +void +gs_manager_set_lock_enabled (GSManager *manager, + gboolean lock_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->lock_enabled != lock_enabled) + { + manager->priv->lock_enabled = lock_enabled; + } +} + +void +gs_manager_set_logout_enabled (GSManager *manager, + gboolean logout_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->logout_enabled != logout_enabled) + { + GSList *l; + + manager->priv->logout_enabled = logout_enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_enabled (l->data, logout_enabled); + } + } +} + +void +gs_manager_set_keyboard_enabled (GSManager *manager, + gboolean enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->keyboard_enabled != enabled) + { + GSList *l; + + manager->priv->keyboard_enabled = enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_keyboard_enabled (l->data, enabled); + } + } +} + +void +gs_manager_set_user_switch_enabled (GSManager *manager, + gboolean user_switch_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->user_switch_enabled != user_switch_enabled) + { + GSList *l; + + manager->priv->user_switch_enabled = user_switch_enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_user_switch_enabled (l->data, user_switch_enabled); + } + } +} + +static gboolean +activate_lock_timeout (GSManager *manager) +{ + if (manager->priv->lock_enabled) + { + gs_manager_set_lock_active (manager, TRUE); + } + + manager->priv->lock_timeout_id = 0; + + return FALSE; +} + +static void +remove_lock_timer (GSManager *manager) +{ + if (manager->priv->lock_timeout_id != 0) + { + g_source_remove (manager->priv->lock_timeout_id); + manager->priv->lock_timeout_id = 0; + } +} + +static void +add_lock_timer (GSManager *manager, + glong timeout) +{ + manager->priv->lock_timeout_id = g_timeout_add (timeout, + (GSourceFunc)activate_lock_timeout, + manager); +} + +void +gs_manager_set_lock_timeout (GSManager *manager, + glong lock_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->lock_timeout != lock_timeout) + { + + manager->priv->lock_timeout = lock_timeout; + + if (manager->priv->active + && ! manager->priv->lock_active + && (lock_timeout >= 0)) + { + + glong elapsed = (time (NULL) - manager->priv->activate_time) * 1000; + + remove_lock_timer (manager); + + if (elapsed >= lock_timeout) + { + activate_lock_timeout (manager); + } + else + { + add_lock_timer (manager, lock_timeout - elapsed); + } + } + } +} + +void +gs_manager_set_logout_timeout (GSManager *manager, + glong logout_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->logout_timeout != logout_timeout) + { + GSList *l; + + manager->priv->logout_timeout = logout_timeout; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_timeout (l->data, logout_timeout); + } + } +} + +void +gs_manager_set_logout_command (GSManager *manager, + const char *command) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->logout_command); + + if (command) + { + manager->priv->logout_command = g_strdup (command); + } + else + { + manager->priv->logout_command = NULL; + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_command (l->data, manager->priv->logout_command); + } +} + +void +gs_manager_set_keyboard_command (GSManager *manager, + const char *command) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->keyboard_command); + + if (command) + { + manager->priv->keyboard_command = g_strdup (command); + } + else + { + manager->priv->keyboard_command = NULL; + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_keyboard_command (l->data, manager->priv->keyboard_command); + } +} + +void +gs_manager_set_status_message (GSManager *manager, + const char *status_message) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->status_message); + + manager->priv->status_message = g_strdup (status_message); + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_status_message (l->data, manager->priv->status_message); + } +} + +gboolean +gs_manager_cycle (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + gs_debug ("cycling jobs"); + + if (! manager->priv->active) + { + return FALSE; + } + + if (manager->priv->dialog_up) + { + return FALSE; + } + + if (manager->priv->throttled) + { + return FALSE; + } + + manager_cycle_jobs (manager); + + return TRUE; +} + +static gboolean +cycle_timeout (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->dialog_up) + { + gs_manager_cycle (manager); + } + + return TRUE; +} + +static void +remove_cycle_timer (GSManager *manager) +{ + if (manager->priv->cycle_timeout_id != 0) + { + g_source_remove (manager->priv->cycle_timeout_id); + manager->priv->cycle_timeout_id = 0; + } +} + +static void +add_cycle_timer (GSManager *manager, + glong timeout) +{ + manager->priv->cycle_timeout_id = g_timeout_add (timeout, + (GSourceFunc)cycle_timeout, + manager); +} + +void +gs_manager_set_cycle_timeout (GSManager *manager, + glong cycle_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->cycle_timeout != cycle_timeout) + { + + manager->priv->cycle_timeout = cycle_timeout; + + if (manager->priv->active && (cycle_timeout >= 0)) + { + glong timeout; + glong elapsed = (time (NULL) - manager->priv->activate_time) * 1000; + + remove_cycle_timer (manager); + + if (elapsed >= cycle_timeout) + { + timeout = 0; + } + else + { + timeout = cycle_timeout - elapsed; + } + + add_cycle_timer (manager, timeout); + + } + } +} + +static void +gs_manager_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSManager *self; + + self = GS_MANAGER (object); + + switch (prop_id) + { + case PROP_THROTTLED: + gs_manager_set_throttled (self, g_value_get_boolean (value)); + break; + case PROP_LOCK_ENABLED: + gs_manager_set_lock_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOCK_TIMEOUT: + gs_manager_set_lock_timeout (self, g_value_get_long (value)); + break; + case PROP_LOGOUT_ENABLED: + gs_manager_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_ENABLED: + gs_manager_set_keyboard_enabled (self, g_value_get_boolean (value)); + break; + case PROP_USER_SWITCH_ENABLED: + gs_manager_set_user_switch_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_TIMEOUT: + gs_manager_set_logout_timeout (self, g_value_get_long (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_manager_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_KEYBOARD_COMMAND: + gs_manager_set_keyboard_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_manager_set_status_message (self, g_value_get_string (value)); + break; + case PROP_CYCLE_TIMEOUT: + gs_manager_set_cycle_timeout (self, g_value_get_long (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_manager_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSManager *self; + + self = GS_MANAGER (object); + + switch (prop_id) + { + case PROP_THROTTLED: + g_value_set_boolean (value, self->priv->throttled); + break; + case PROP_LOCK_ENABLED: + g_value_set_boolean (value, self->priv->lock_enabled); + break; + case PROP_LOCK_TIMEOUT: + g_value_set_long (value, self->priv->lock_timeout); + break; + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_KEYBOARD_ENABLED: + g_value_set_boolean (value, self->priv->keyboard_enabled); + break; + case PROP_USER_SWITCH_ENABLED: + g_value_set_boolean (value, self->priv->user_switch_enabled); + break; + case PROP_LOGOUT_TIMEOUT: + g_value_set_long (value, self->priv->logout_timeout); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_KEYBOARD_COMMAND: + g_value_set_string (value, self->priv->keyboard_command); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + case PROP_CYCLE_TIMEOUT: + g_value_set_long (value, self->priv->cycle_timeout); + break; + case PROP_ACTIVE: + g_value_set_boolean (value, self->priv->active); + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_manager_class_init (GSManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_manager_finalize; + object_class->get_property = gs_manager_get_property; + object_class->set_property = gs_manager_set_property; + + signals [ACTIVATED] = + g_signal_new ("activated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, activated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [DEACTIVATED] = + g_signal_new ("deactivated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, deactivated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [AUTH_REQUEST_BEGIN] = + g_signal_new ("auth-request-begin", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, auth_request_begin), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [AUTH_REQUEST_END] = + g_signal_new ("auth-request-end", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, auth_request_end), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_object_class_install_property (object_class, + PROP_ACTIVE, + g_param_spec_boolean ("active", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_LOCK_ENABLED, + g_param_spec_boolean ("lock-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOCK_TIMEOUT, + g_param_spec_long ("lock-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_USER_SWITCH_ENABLED, + g_param_spec_boolean ("user-switch-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_LOGOUT_TIMEOUT, + g_param_spec_long ("logout-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_CYCLE_TIMEOUT, + g_param_spec_long ("cycle-timeout", + NULL, + NULL, + 10000, + G_MAXLONG, + 300000, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_THROTTLED, + g_param_spec_boolean ("throttled", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_type_class_add_private (klass, sizeof (GSManagerPrivate)); +} + +static void +on_bg_changed (MateBG *bg, + GSManager *manager) +{ + gs_debug ("background changed"); +} + +static void +mateconf_changed_callback (MateConfClient *client, + guint cnxn_id, + MateConfEntry *entry, + GSManager *manager) +{ + mate_bg_load_from_preferences (manager->priv->bg, + manager->priv->client); +} + +static void +watch_bg_preferences (GSManager *manager) +{ + g_assert (manager->priv->bg_notify_id == 0); + + mateconf_client_add_dir (manager->priv->client, + MATE_BG_KEY_DIR, + MATECONF_CLIENT_PRELOAD_NONE, + NULL); + manager->priv->bg_notify_id = mateconf_client_notify_add (manager->priv->client, + MATE_BG_KEY_DIR, + (MateConfClientNotifyFunc)mateconf_changed_callback, + manager, + NULL, + NULL); +} + +static MateConfClient * +get_mateconf_client (void) +{ + MateConfClient *client; + GSList *addresses; + GError *error; + MateConfEngine *engine; + + client = NULL; + addresses = NULL; + + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.mandatory"); + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.system"); + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.defaults"); + addresses = g_slist_reverse (addresses); + + error = NULL; + engine = mateconf_engine_get_for_addresses (addresses, &error); + if (engine == NULL) + { + gs_debug ("Unable to get mateconf engine for addresses: %s", error->message); + g_error_free (error); + } + else + { + client = mateconf_client_get_for_engine (engine); + } + + g_slist_free (addresses); + + return client; +} + +static void +gs_manager_init (GSManager *manager) +{ + manager->priv = GS_MANAGER_GET_PRIVATE (manager); + + manager->priv->fade = gs_fade_new (); + manager->priv->grab = gs_grab_new (); + manager->priv->theme_manager = gs_theme_manager_new (); + + manager->priv->client = get_mateconf_client (); + if (manager->priv->client != NULL) + { + manager->priv->bg = mate_bg_new (); + + g_signal_connect (manager->priv->bg, + "changed", + G_CALLBACK (on_bg_changed), + manager); + watch_bg_preferences (manager); + + mate_bg_load_from_preferences (manager->priv->bg, manager->priv->client); + } +} + +static void +remove_timers (GSManager *manager) +{ + remove_lock_timer (manager); + remove_cycle_timer (manager); +} + +static void +remove_unfade_idle (GSManager *manager) +{ + if (manager->priv->unfade_idle_id > 0) + { + g_source_remove (manager->priv->unfade_idle_id); + manager->priv->unfade_idle_id = 0; + } +} + + +static gboolean +window_deactivated_idle (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + /* don't deactivate directly but only emit a signal + so that we let the parent deactivate */ + g_signal_emit (manager, signals [DEACTIVATED], 0); + + return FALSE; +} + +static void +window_deactivated_cb (GSWindow *window, + GSManager *manager) +{ + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_idle_add ((GSourceFunc)window_deactivated_idle, manager); +} + +static GSWindow * +find_window_at_pointer (GSManager *manager) +{ + GdkDisplay *display; + GdkScreen *screen; + int monitor; + int x, y; + GSWindow *window; + int screen_num; + GSList *l; + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, &x, &y, NULL); + monitor = gdk_screen_get_monitor_at_point (screen, x, y); + screen_num = gdk_screen_get_number (screen); + + /* Find the gs-window that is on that screen */ + window = NULL; + for (l = manager->priv->windows; l; l = l->next) + { + GSWindow *win = GS_WINDOW (l->data); + if (gs_window_get_screen (win) == screen + && gs_window_get_monitor (win) == monitor) + { + window = win; + } + } + + if (window == NULL) + { + gs_debug ("WARNING: Could not find the GSWindow for screen %d", screen_num); + /* take the first one */ + window = manager->priv->windows->data; + } + else + { + gs_debug ("Requesting unlock for screen %d", screen_num); + } + + return window; +} + +void +gs_manager_show_message (GSManager *manager, + const char *summary, + const char *body, + const char *icon) +{ + GSWindow *window; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + /* Find the GSWindow that contains the pointer */ + window = find_window_at_pointer (manager); + gs_window_show_message (window, summary, body, icon); + + gs_manager_request_unlock (manager); +} + +static gboolean +manager_maybe_grab_window (GSManager *manager, + GSWindow *window) +{ + GdkDisplay *display; + GdkScreen *screen; + int monitor; + int x, y; + gboolean grabbed; + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, &x, &y, NULL); + monitor = gdk_screen_get_monitor_at_point (screen, x, y); + + gdk_flush (); + grabbed = FALSE; + if (gs_window_get_screen (window) == screen + && gs_window_get_monitor (window) == monitor) + { + gs_debug ("Moving grab to %p", window); + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + grabbed = TRUE; + } + + return grabbed; +} + +static void +window_grab_broken_cb (GSWindow *window, + GdkEventGrabBroken *event, + GSManager *manager) +{ + gs_debug ("GRAB BROKEN!"); + if (event->keyboard) + { + gs_grab_keyboard_reset (manager->priv->grab); + } + else + { + gs_grab_mouse_reset (manager->priv->grab); + } +} + +static gboolean +unfade_idle (GSManager *manager) +{ + gs_debug ("resetting fade"); + gs_fade_reset (manager->priv->fade); + manager->priv->unfade_idle_id = 0; + return FALSE; +} + + +static void +add_unfade_idle (GSManager *manager) +{ + remove_unfade_idle (manager); + manager->priv->unfade_idle_id = g_timeout_add (500, (GSourceFunc)unfade_idle, manager); +} + +static gboolean +window_map_event_cb (GSWindow *window, + GdkEvent *event, + GSManager *manager) +{ + gs_debug ("Handling window map_event event"); + + manager_maybe_grab_window (manager, window); + + manager_maybe_start_job_for_window (manager, window); + + return FALSE; +} + +static void +window_map_cb (GSWindow *window, + GSManager *manager) +{ + gs_debug ("Handling window map event"); +} + +static void +window_unmap_cb (GSWindow *window, + GSManager *manager) +{ + gs_debug ("window unmapped!"); +} + +static void +apply_background_to_window (GSManager *manager, + GSWindow *window) +{ + GdkPixmap *pixmap; + GdkScreen *screen; + int width; + int height; + + if (manager->priv->bg == NULL) + { + gs_debug ("No background available"); + gs_window_set_background_pixmap (window, NULL); + } + + screen = gs_window_get_screen (window); + width = gdk_screen_get_width (screen); + height = gdk_screen_get_height (screen); + gs_debug ("Creating pixmap background w:%d h:%d", width, height); + pixmap = mate_bg_create_pixmap (manager->priv->bg, + gs_window_get_gdk_window (window), + width, + height, + FALSE); + gs_window_set_background_pixmap (window, pixmap); + g_object_unref (pixmap); +} + +static void +manager_show_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + apply_background_to_window (manager, window); + + job = gs_job_new_for_widget (gs_window_get_drawing_area (window)); + + manager_select_theme_for_job (manager, job); + manager_add_job_for_window (manager, window, job); + + manager->priv->activate_time = time (NULL); + + if (manager->priv->lock_timeout >= 0) + { + remove_lock_timer (manager); + add_lock_timer (manager, manager->priv->lock_timeout); + } + + if (manager->priv->cycle_timeout >= 10000) + { + remove_cycle_timer (manager); + add_cycle_timer (manager, manager->priv->cycle_timeout); + } + + add_unfade_idle (manager); + + /* FIXME: only emit signal once */ + g_signal_emit (manager, signals [ACTIVATED], 0); +} + +static void +window_show_cb (GSWindow *window, + GSManager *manager) +{ + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + g_return_if_fail (window != NULL); + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Handling window show"); + manager_show_window (manager, window); +} + +static void +maybe_set_window_throttle (GSManager *manager, + GSWindow *window, + gboolean throttled) +{ + if (throttled) + { + manager_maybe_stop_job_for_window (manager, window); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +window_obscured_cb (GSWindow *window, + GParamSpec *pspec, + GSManager *manager) +{ + gboolean obscured; + + obscured = gs_window_is_obscured (window); + gs_debug ("Handling window obscured: %s", obscured ? "obscured" : "unobscured"); + + maybe_set_window_throttle (manager, window, obscured); + + if (! obscured) + { + gs_manager_request_unlock (manager); + } +} + +static void +handle_window_dialog_up (GSManager *manager, + GSWindow *window) +{ + GSList *l; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Handling dialog up"); + + g_signal_emit (manager, signals [AUTH_REQUEST_BEGIN], 0); + + manager->priv->dialog_up = TRUE; + /* Make all other windows insensitive so we don't get events */ + for (l = manager->priv->windows; l; l = l->next) + { + if (l->data != window) + { + gtk_widget_set_sensitive (GTK_WIDGET (l->data), FALSE); + } + } + + /* Move keyboard and mouse grabs so dialog can be used */ + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + + /* Release the pointer grab while dialog is up so that + the dialog can be used. We'll regrab it when the dialog goes down. */ + gs_grab_release_mouse (manager->priv->grab); + + if (! manager->priv->throttled) + { + gs_debug ("Suspending jobs"); + + manager_suspend_jobs (manager); + } +} + +static void +handle_window_dialog_down (GSManager *manager, + GSWindow *window) +{ + GSList *l; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Handling dialog down"); + + /* Regrab the mouse */ + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + + /* Make all windows sensitive so we get events */ + for (l = manager->priv->windows; l; l = l->next) + { + gtk_widget_set_sensitive (GTK_WIDGET (l->data), TRUE); + } + + manager->priv->dialog_up = FALSE; + + if (! manager->priv->throttled) + { + manager_resume_jobs (manager); + } + + g_signal_emit (manager, signals [AUTH_REQUEST_END], 0); +} + +static void +window_dialog_up_changed_cb (GSWindow *window, + GParamSpec *pspec, + GSManager *manager) +{ + gboolean up; + + up = gs_window_is_dialog_up (window); + gs_debug ("Handling window dialog up changed: %s", up ? "up" : "down"); + if (up) + { + handle_window_dialog_up (manager, window); + } + else + { + handle_window_dialog_down (manager, window); + } +} + +static gboolean +window_activity_cb (GSWindow *window, + GSManager *manager) +{ + gboolean handled; + + handled = gs_manager_request_unlock (manager); + + return handled; +} + +static void +disconnect_window_signals (GSManager *manager, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (window, window_deactivated_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_activity_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_show_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_map_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_map_event_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_obscured_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_dialog_up_changed_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_unmap_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_grab_broken_cb, manager); +} + +static void +window_destroyed_cb (GtkWindow *window, + GSManager *manager) +{ + disconnect_window_signals (manager, GS_WINDOW (window)); +} + +static void +connect_window_signals (GSManager *manager, + GSWindow *window) +{ + g_signal_connect_object (window, "destroy", + G_CALLBACK (window_destroyed_cb), manager, 0); + g_signal_connect_object (window, "activity", + G_CALLBACK (window_activity_cb), manager, 0); + g_signal_connect_object (window, "deactivated", + G_CALLBACK (window_deactivated_cb), manager, 0); + g_signal_connect_object (window, "show", + G_CALLBACK (window_show_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "map", + G_CALLBACK (window_map_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "map_event", + G_CALLBACK (window_map_event_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "notify::obscured", + G_CALLBACK (window_obscured_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "notify::dialog-up", + G_CALLBACK (window_dialog_up_changed_cb), manager, 0); + g_signal_connect_object (window, "unmap", + G_CALLBACK (window_unmap_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "grab_broken_event", + G_CALLBACK (window_grab_broken_cb), manager, G_CONNECT_AFTER); +} + +static void +gs_manager_create_window_for_monitor (GSManager *manager, + GdkScreen *screen, + int monitor) +{ + GSWindow *window; + GdkRectangle rect; + + gdk_screen_get_monitor_geometry (screen, monitor, &rect); + + gs_debug ("Creating window for monitor %d [%d,%d] (%dx%d)", + monitor, rect.x, rect.y, rect.width, rect.height); + + window = gs_window_new (screen, monitor, manager->priv->lock_active); + + gs_window_set_user_switch_enabled (window, manager->priv->user_switch_enabled); + gs_window_set_logout_enabled (window, manager->priv->logout_enabled); + gs_window_set_logout_timeout (window, manager->priv->logout_timeout); + gs_window_set_logout_command (window, manager->priv->logout_command); + gs_window_set_keyboard_enabled (window, manager->priv->keyboard_enabled); + gs_window_set_keyboard_command (window, manager->priv->keyboard_command); + gs_window_set_status_message (window, manager->priv->status_message); + + connect_window_signals (manager, window); + + manager->priv->windows = g_slist_append (manager->priv->windows, window); + + if (manager->priv->active && !manager->priv->fading) + { + gtk_widget_show (GTK_WIDGET (window)); + } +} + +static void +on_screen_monitors_changed (GdkScreen *screen, + GSManager *manager) +{ + GSList *l; + int n_monitors; + int n_windows; + int i; + + n_monitors = gdk_screen_get_n_monitors (screen); + n_windows = g_slist_length (manager->priv->windows); + + gs_debug ("Monitors changed for screen %d: num=%d", + gdk_screen_get_number (screen), + n_monitors); + + if (n_monitors > n_windows) + { + + /* Tear down unlock dialog in case we want to move it + * to a new monitor + */ + l = manager->priv->windows; + while (l != NULL) + { + gs_window_cancel_unlock_request (GS_WINDOW (l->data)); + l = l->next; + } + + /* add more windows */ + for (i = n_windows; i < n_monitors; i++) + { + gs_manager_create_window_for_monitor (manager, screen, i); + } + + /* And put unlock dialog up where ever it's supposed to be + */ + gs_manager_request_unlock (manager); + } + else + { + + gdk_x11_grab_server (); + + /* remove the extra windows */ + l = manager->priv->windows; + while (l != NULL) + { + GdkScreen *this_screen; + int this_monitor; + GSList *next = l->next; + + this_screen = gs_window_get_screen (GS_WINDOW (l->data)); + this_monitor = gs_window_get_monitor (GS_WINDOW (l->data)); + if (this_screen == screen && this_monitor >= n_monitors) + { + manager_maybe_stop_job_for_window (manager, GS_WINDOW (l->data)); + g_hash_table_remove (manager->priv->jobs, l->data); + gs_window_destroy (GS_WINDOW (l->data)); + manager->priv->windows = g_slist_delete_link (manager->priv->windows, l); + } + l = next; + } + + /* make sure there is a lock dialog on a connected monitor, + * and that the keyboard is still properly grabbed after all + * the windows above got destroyed*/ + if (n_windows > n_monitors) + { + gs_manager_request_unlock (manager); + } + + gdk_flush (); + gdk_x11_ungrab_server (); + } +} + +static void +gs_manager_destroy_windows (GSManager *manager) +{ + GdkDisplay *display; + GSList *l; + int n_screens; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->windows == NULL) + { + return; + } + + display = gdk_display_get_default (); + + n_screens = gdk_display_get_n_screens (display); + + for (i = 0; i < n_screens; i++) + { + g_signal_handlers_disconnect_by_func (gdk_display_get_screen (display, i), + on_screen_monitors_changed, + manager); + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_destroy (l->data); + } + g_slist_free (manager->priv->windows); + manager->priv->windows = NULL; +} + +static void +gs_manager_finalize (GObject *object) +{ + GSManager *manager; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_MANAGER (object)); + + manager = GS_MANAGER (object); + + g_return_if_fail (manager->priv != NULL); + + if (manager->priv->bg_notify_id != 0) + { + mateconf_client_remove_dir (manager->priv->client, + MATE_BG_KEY_DIR, + NULL); + mateconf_client_notify_remove (manager->priv->client, + manager->priv->bg_notify_id); + manager->priv->bg_notify_id = 0; + } + if (manager->priv->bg != NULL) + { + g_object_unref (manager->priv->bg); + } + if (manager->priv->client != NULL) + { + g_object_unref (manager->priv->client); + } + + free_themes (manager); + g_free (manager->priv->logout_command); + g_free (manager->priv->keyboard_command); + g_free (manager->priv->status_message); + + remove_unfade_idle (manager); + remove_timers (manager); + + gs_grab_release (manager->priv->grab); + + manager_stop_jobs (manager); + + gs_manager_destroy_windows (manager); + + manager->priv->active = FALSE; + manager->priv->activate_time = 0; + manager->priv->lock_enabled = FALSE; + + g_object_unref (manager->priv->fade); + g_object_unref (manager->priv->grab); + g_object_unref (manager->priv->theme_manager); + + G_OBJECT_CLASS (gs_manager_parent_class)->finalize (object); +} + +static void +gs_manager_create_windows_for_screen (GSManager *manager, + GdkScreen *screen) +{ + int n_monitors; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + g_return_if_fail (GDK_IS_SCREEN (screen)); + + g_object_ref (manager); + g_object_ref (screen); + + n_monitors = gdk_screen_get_n_monitors (screen); + + gs_debug ("Creating %d windows for screen %d", n_monitors, gdk_screen_get_number (screen)); + + for (i = 0; i < n_monitors; i++) + { + gs_manager_create_window_for_monitor (manager, screen, i); + } + + g_object_unref (screen); + g_object_unref (manager); +} + +static void +gs_manager_create_windows (GSManager *manager) +{ + GdkDisplay *display; + int n_screens; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_assert (manager->priv->windows == NULL); + + display = gdk_display_get_default (); + n_screens = gdk_display_get_n_screens (display); + + for (i = 0; i < n_screens; i++) + { + g_signal_connect (gdk_display_get_screen (display, i), + "monitors-changed", + G_CALLBACK (on_screen_monitors_changed), + manager); + + gs_manager_create_windows_for_screen (manager, gdk_display_get_screen (display, i)); + } +} + +GSManager * +gs_manager_new (void) +{ + GObject *manager; + + manager = g_object_new (GS_TYPE_MANAGER, NULL); + + return GS_MANAGER (manager); +} + +static void +show_windows (GSList *windows) +{ + GSList *l; + + for (l = windows; l; l = l->next) + { + gtk_widget_show (GTK_WIDGET (l->data)); + } +} + +static void +remove_job (GSJob *job) +{ + if (job == NULL) + { + return; + } + + gs_job_stop (job); + g_object_unref (job); +} + +static void +fade_done_cb (GSFade *fade, + GSManager *manager) +{ + gs_debug ("fade completed, showing windows"); + show_windows (manager->priv->windows); + manager->priv->fading = FALSE; +} + +static gboolean +gs_manager_activate (GSManager *manager) +{ + gboolean do_fade; + gboolean res; + + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (manager->priv->active) + { + gs_debug ("Trying to activate manager when already active"); + return FALSE; + } + + res = gs_grab_grab_root (manager->priv->grab, FALSE); + if (! res) + { + return FALSE; + } + + if (manager->priv->windows == NULL) + { + gs_manager_create_windows (GS_MANAGER (manager)); + } + + manager->priv->jobs = g_hash_table_new_full (g_direct_hash, + g_direct_equal, + NULL, + (GDestroyNotify)remove_job); + + manager->priv->active = TRUE; + + /* fade to black and show windows */ + do_fade = TRUE; + if (do_fade) + { + manager->priv->fading = TRUE; + gs_debug ("fading out"); + gs_fade_async (manager->priv->fade, + FADE_TIMEOUT, + (GSFadeDoneFunc)fade_done_cb, + manager); + + while (manager->priv->fading) + { + gtk_main_iteration (); + } + } + else + { + show_windows (manager->priv->windows); + } + + return TRUE; +} + +static gboolean +gs_manager_deactivate (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->active) + { + gs_debug ("Trying to deactivate a screensaver that is not active"); + return FALSE; + } + + remove_unfade_idle (manager); + gs_fade_reset (manager->priv->fade); + remove_timers (manager); + + gs_grab_release (manager->priv->grab); + + manager_stop_jobs (manager); + + gs_manager_destroy_windows (manager); + + /* reset state */ + manager->priv->active = FALSE; + manager->priv->activate_time = 0; + manager->priv->lock_active = FALSE; + manager->priv->dialog_up = FALSE; + manager->priv->fading = FALSE; + + return TRUE; +} + +gboolean +gs_manager_set_active (GSManager *manager, + gboolean active) +{ + gboolean res; + + if (active) + { + res = gs_manager_activate (manager); + } + else + { + res = gs_manager_deactivate (manager); + } + + return res; +} + +gboolean +gs_manager_get_active (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + return manager->priv->active; +} + +gboolean +gs_manager_request_unlock (GSManager *manager) +{ + GSWindow *window; + + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->active) + { + gs_debug ("Request unlock but manager is not active"); + return FALSE; + } + + if (manager->priv->dialog_up) + { + gs_debug ("Request unlock but dialog is already up"); + return FALSE; + } + + if (manager->priv->fading) + { + gs_debug ("Request unlock so finishing fade"); + gs_fade_finish (manager->priv->fade); + } + + if (manager->priv->windows == NULL) + { + gs_debug ("We don't have any windows!"); + return FALSE; + } + + /* Find the GSWindow that contains the pointer */ + window = find_window_at_pointer (manager); + gs_window_request_unlock (window); + + return TRUE; +} + +void +gs_manager_cancel_unlock_request (GSManager *manager) +{ + GSList *l; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_cancel_unlock_request (l->data); + } +} diff --git a/src/gs-manager.c.orig b/src/gs-manager.c.orig new file mode 100644 index 0000000..47c5005 --- /dev/null +++ b/src/gs-manager.c.orig @@ -0,0 +1,2030 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2008 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include + +#define MATE_DESKTOP_USE_UNSTABLE_API +#include + +#include "gs-prefs.h" /* for GSSaverMode */ + +#include "gs-manager.h" +#include "gs-window.h" +#include "gs-theme-manager.h" +#include "gs-job.h" +#include "gs-grab.h" +#include "gs-fade.h" +#include "gs-debug.h" + +static void gs_manager_class_init (GSManagerClass *klass); +static void gs_manager_init (GSManager *manager); +static void gs_manager_finalize (GObject *object); + +#define GS_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_MANAGER, GSManagerPrivate)) + +struct GSManagerPrivate +{ + GSList *windows; + GHashTable *jobs; + + GSThemeManager *theme_manager; + MateConfClient *client; + MateBG *bg; + guint bg_notify_id; + + /* Policy */ + glong lock_timeout; + glong cycle_timeout; + glong logout_timeout; + + guint lock_enabled : 1; + guint logout_enabled : 1; + guint keyboard_enabled : 1; + guint user_switch_enabled : 1; + guint throttled : 1; + + char *logout_command; + char *keyboard_command; + + char *status_message; + + /* State */ + guint active : 1; + guint lock_active : 1; + + guint fading : 1; + guint dialog_up : 1; + + time_t activate_time; + + guint lock_timeout_id; + guint cycle_timeout_id; + + GSList *themes; + GSSaverMode saver_mode; + GSGrab *grab; + GSFade *fade; + guint unfade_idle_id; +}; + +enum +{ + ACTIVATED, + DEACTIVATED, + AUTH_REQUEST_BEGIN, + AUTH_REQUEST_END, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_LOCK_ENABLED, + PROP_LOGOUT_ENABLED, + PROP_USER_SWITCH_ENABLED, + PROP_KEYBOARD_ENABLED, + PROP_LOCK_TIMEOUT, + PROP_CYCLE_TIMEOUT, + PROP_LOGOUT_TIMEOUT, + PROP_LOGOUT_COMMAND, + PROP_KEYBOARD_COMMAND, + PROP_STATUS_MESSAGE, + PROP_ACTIVE, + PROP_THROTTLED, +}; + +#define FADE_TIMEOUT 1000 + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSManager, gs_manager, G_TYPE_OBJECT) + +static void +manager_add_job_for_window (GSManager *manager, + GSWindow *window, + GSJob *job) +{ + if (manager->priv->jobs == NULL) + { + return; + } + + g_hash_table_insert (manager->priv->jobs, window, job); +} + +static const char * +select_theme (GSManager *manager) +{ + const char *theme = NULL; + + g_return_val_if_fail (manager != NULL, NULL); + g_return_val_if_fail (GS_IS_MANAGER (manager), NULL); + + if (manager->priv->saver_mode == GS_MODE_BLANK_ONLY) + { + return NULL; + } + + if (manager->priv->themes) + { + int number = 0; + + if (manager->priv->saver_mode == GS_MODE_RANDOM) + { + g_random_set_seed (time (NULL)); + number = g_random_int_range (0, g_slist_length (manager->priv->themes)); + } + theme = g_slist_nth_data (manager->priv->themes, number); + } + + return theme; +} + +static GSJob * +lookup_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + if (manager->priv->jobs == NULL) + { + return NULL; + } + + job = g_hash_table_lookup (manager->priv->jobs, window); + + return job; +} + +static void +manager_maybe_stop_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + job = lookup_job_for_window (manager, window); + + if (job == NULL) + { + gs_debug ("Job not found for window"); + return; + } + + gs_job_stop (job); +} + +static void +manager_maybe_start_job_for_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + job = lookup_job_for_window (manager, window); + + if (job == NULL) + { + gs_debug ("Job not found for window"); + return; + } + + if (! manager->priv->dialog_up) + { + if (! manager->priv->throttled) + { + if (! gs_job_is_running (job)) + { + if (! gs_window_is_obscured (window)) + { + gs_debug ("Starting job for window"); + gs_job_start (job); + } + else + { + gs_debug ("Window is obscured deferring start of job"); + } + } + else + { + gs_debug ("Not starting job because job is running"); + } + } + else + { + gs_debug ("Not starting job because throttled"); + } + } + else + { + gs_debug ("Not starting job because dialog is up"); + } +} + +static void +manager_select_theme_for_job (GSManager *manager, + GSJob *job) +{ + const char *theme; + + theme = select_theme (manager); + + if (theme != NULL) + { + GSThemeInfo *info; + const char *command; + + command = NULL; + + info = gs_theme_manager_lookup_theme_info (manager->priv->theme_manager, theme); + if (info != NULL) + { + command = gs_theme_info_get_exec (info); + } + else + { + gs_debug ("Could not find information for theme: %s", + theme); + } + + gs_job_set_command (job, command); + + + if (info != NULL) + { + gs_theme_info_unref (info); + } + } + else + { + gs_job_set_command (job, NULL); + } +} + +static void +cycle_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + gs_job_stop (job); + manager_select_theme_for_job (manager, job); + manager_maybe_start_job_for_window (manager, window); +} + +static void +manager_cycle_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) cycle_job, manager); + } +} + +static void +throttle_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + if (manager->priv->throttled) + { + gs_job_stop (job); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +manager_throttle_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) throttle_job, manager); + } +} + +static void +resume_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + if (gs_job_is_running (job)) + { + gs_job_suspend (job, FALSE); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +manager_resume_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) resume_job, manager); + } +} + +static void +suspend_job (GSWindow *window, + GSJob *job, + GSManager *manager) +{ + gs_job_suspend (job, TRUE); +} + +static void +manager_suspend_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_foreach (manager->priv->jobs, (GHFunc) suspend_job, manager); + } +} + +static void +manager_stop_jobs (GSManager *manager) +{ + if (manager->priv->jobs != NULL) + { + g_hash_table_destroy (manager->priv->jobs); + + } + manager->priv->jobs = NULL; +} + +void +gs_manager_set_mode (GSManager *manager, + GSSaverMode mode) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + manager->priv->saver_mode = mode; +} + +static void +free_themes (GSManager *manager) +{ + if (manager->priv->themes) + { + g_slist_foreach (manager->priv->themes, (GFunc)g_free, NULL); + g_slist_free (manager->priv->themes); + } +} + +void +gs_manager_set_themes (GSManager *manager, + GSList *themes) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + free_themes (manager); + manager->priv->themes = NULL; + + for (l = themes; l; l = l->next) + { + manager->priv->themes = g_slist_append (manager->priv->themes, g_strdup (l->data)); + } +} + +void +gs_manager_set_throttled (GSManager *manager, + gboolean throttled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->throttled != throttled) + { + GSList *l; + + manager->priv->throttled = throttled; + + if (! manager->priv->dialog_up) + { + + manager_throttle_jobs (manager); + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_clear (l->data); + } + } + } +} + +void +gs_manager_get_lock_active (GSManager *manager, + gboolean *lock_active) +{ + if (lock_active != NULL) + { + *lock_active = FALSE; + } + + g_return_if_fail (GS_IS_MANAGER (manager)); + + *lock_active = manager->priv->lock_active; +} + +void +gs_manager_set_lock_active (GSManager *manager, + gboolean lock_active) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Setting lock active: %d", lock_active); + + if (manager->priv->lock_active != lock_active) + { + GSList *l; + + manager->priv->lock_active = lock_active; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_lock_enabled (l->data, lock_active); + } + } +} + +void +gs_manager_get_lock_enabled (GSManager *manager, + gboolean *lock_enabled) +{ + if (lock_enabled != NULL) + { + *lock_enabled = FALSE; + } + + g_return_if_fail (GS_IS_MANAGER (manager)); + + *lock_enabled = manager->priv->lock_enabled; +} + +void +gs_manager_set_lock_enabled (GSManager *manager, + gboolean lock_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->lock_enabled != lock_enabled) + { + manager->priv->lock_enabled = lock_enabled; + } +} + +void +gs_manager_set_logout_enabled (GSManager *manager, + gboolean logout_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->logout_enabled != logout_enabled) + { + GSList *l; + + manager->priv->logout_enabled = logout_enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_enabled (l->data, logout_enabled); + } + } +} + +void +gs_manager_set_keyboard_enabled (GSManager *manager, + gboolean enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->keyboard_enabled != enabled) + { + GSList *l; + + manager->priv->keyboard_enabled = enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_keyboard_enabled (l->data, enabled); + } + } +} + +void +gs_manager_set_user_switch_enabled (GSManager *manager, + gboolean user_switch_enabled) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->user_switch_enabled != user_switch_enabled) + { + GSList *l; + + manager->priv->user_switch_enabled = user_switch_enabled; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_user_switch_enabled (l->data, user_switch_enabled); + } + } +} + +static gboolean +activate_lock_timeout (GSManager *manager) +{ + if (manager->priv->lock_enabled) + { + gs_manager_set_lock_active (manager, TRUE); + } + + manager->priv->lock_timeout_id = 0; + + return FALSE; +} + +static void +remove_lock_timer (GSManager *manager) +{ + if (manager->priv->lock_timeout_id != 0) + { + g_source_remove (manager->priv->lock_timeout_id); + manager->priv->lock_timeout_id = 0; + } +} + +static void +add_lock_timer (GSManager *manager, + glong timeout) +{ + manager->priv->lock_timeout_id = g_timeout_add (timeout, + (GSourceFunc)activate_lock_timeout, + manager); +} + +void +gs_manager_set_lock_timeout (GSManager *manager, + glong lock_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->lock_timeout != lock_timeout) + { + + manager->priv->lock_timeout = lock_timeout; + + if (manager->priv->active + && ! manager->priv->lock_active + && (lock_timeout >= 0)) + { + + glong elapsed = (time (NULL) - manager->priv->activate_time) * 1000; + + remove_lock_timer (manager); + + if (elapsed >= lock_timeout) + { + activate_lock_timeout (manager); + } + else + { + add_lock_timer (manager, lock_timeout - elapsed); + } + } + } +} + +void +gs_manager_set_logout_timeout (GSManager *manager, + glong logout_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->logout_timeout != logout_timeout) + { + GSList *l; + + manager->priv->logout_timeout = logout_timeout; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_timeout (l->data, logout_timeout); + } + } +} + +void +gs_manager_set_logout_command (GSManager *manager, + const char *command) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->logout_command); + + if (command) + { + manager->priv->logout_command = g_strdup (command); + } + else + { + manager->priv->logout_command = NULL; + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_logout_command (l->data, manager->priv->logout_command); + } +} + +void +gs_manager_set_keyboard_command (GSManager *manager, + const char *command) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->keyboard_command); + + if (command) + { + manager->priv->keyboard_command = g_strdup (command); + } + else + { + manager->priv->keyboard_command = NULL; + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_keyboard_command (l->data, manager->priv->keyboard_command); + } +} + +void +gs_manager_set_status_message (GSManager *manager, + const char *status_message) +{ + GSList *l; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_free (manager->priv->status_message); + + manager->priv->status_message = g_strdup (status_message); + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_set_status_message (l->data, manager->priv->status_message); + } +} + +gboolean +gs_manager_cycle (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + gs_debug ("cycling jobs"); + + if (! manager->priv->active) + { + return FALSE; + } + + if (manager->priv->dialog_up) + { + return FALSE; + } + + if (manager->priv->throttled) + { + return FALSE; + } + + manager_cycle_jobs (manager); + + return TRUE; +} + +static gboolean +cycle_timeout (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->dialog_up) + { + gs_manager_cycle (manager); + } + + return TRUE; +} + +static void +remove_cycle_timer (GSManager *manager) +{ + if (manager->priv->cycle_timeout_id != 0) + { + g_source_remove (manager->priv->cycle_timeout_id); + manager->priv->cycle_timeout_id = 0; + } +} + +static void +add_cycle_timer (GSManager *manager, + glong timeout) +{ + manager->priv->cycle_timeout_id = g_timeout_add (timeout, + (GSourceFunc)cycle_timeout, + manager); +} + +void +gs_manager_set_cycle_timeout (GSManager *manager, + glong cycle_timeout) +{ + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->cycle_timeout != cycle_timeout) + { + + manager->priv->cycle_timeout = cycle_timeout; + + if (manager->priv->active && (cycle_timeout >= 0)) + { + glong timeout; + glong elapsed = (time (NULL) - manager->priv->activate_time) * 1000; + + remove_cycle_timer (manager); + + if (elapsed >= cycle_timeout) + { + timeout = 0; + } + else + { + timeout = cycle_timeout - elapsed; + } + + add_cycle_timer (manager, timeout); + + } + } +} + +static void +gs_manager_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSManager *self; + + self = GS_MANAGER (object); + + switch (prop_id) + { + case PROP_THROTTLED: + gs_manager_set_throttled (self, g_value_get_boolean (value)); + break; + case PROP_LOCK_ENABLED: + gs_manager_set_lock_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOCK_TIMEOUT: + gs_manager_set_lock_timeout (self, g_value_get_long (value)); + break; + case PROP_LOGOUT_ENABLED: + gs_manager_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_ENABLED: + gs_manager_set_keyboard_enabled (self, g_value_get_boolean (value)); + break; + case PROP_USER_SWITCH_ENABLED: + gs_manager_set_user_switch_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_TIMEOUT: + gs_manager_set_logout_timeout (self, g_value_get_long (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_manager_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_KEYBOARD_COMMAND: + gs_manager_set_keyboard_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_manager_set_status_message (self, g_value_get_string (value)); + break; + case PROP_CYCLE_TIMEOUT: + gs_manager_set_cycle_timeout (self, g_value_get_long (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_manager_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSManager *self; + + self = GS_MANAGER (object); + + switch (prop_id) + { + case PROP_THROTTLED: + g_value_set_boolean (value, self->priv->throttled); + break; + case PROP_LOCK_ENABLED: + g_value_set_boolean (value, self->priv->lock_enabled); + break; + case PROP_LOCK_TIMEOUT: + g_value_set_long (value, self->priv->lock_timeout); + break; + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_KEYBOARD_ENABLED: + g_value_set_boolean (value, self->priv->keyboard_enabled); + break; + case PROP_USER_SWITCH_ENABLED: + g_value_set_boolean (value, self->priv->user_switch_enabled); + break; + case PROP_LOGOUT_TIMEOUT: + g_value_set_long (value, self->priv->logout_timeout); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_KEYBOARD_COMMAND: + g_value_set_string (value, self->priv->keyboard_command); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + case PROP_CYCLE_TIMEOUT: + g_value_set_long (value, self->priv->cycle_timeout); + break; + case PROP_ACTIVE: + g_value_set_boolean (value, self->priv->active); + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_manager_class_init (GSManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_manager_finalize; + object_class->get_property = gs_manager_get_property; + object_class->set_property = gs_manager_set_property; + + signals [ACTIVATED] = + g_signal_new ("activated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, activated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [DEACTIVATED] = + g_signal_new ("deactivated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, deactivated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [AUTH_REQUEST_BEGIN] = + g_signal_new ("auth-request-begin", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, auth_request_begin), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + signals [AUTH_REQUEST_END] = + g_signal_new ("auth-request-end", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSManagerClass, auth_request_end), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_object_class_install_property (object_class, + PROP_ACTIVE, + g_param_spec_boolean ("active", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_LOCK_ENABLED, + g_param_spec_boolean ("lock-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOCK_TIMEOUT, + g_param_spec_long ("lock-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_USER_SWITCH_ENABLED, + g_param_spec_boolean ("user-switch-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_LOGOUT_TIMEOUT, + g_param_spec_long ("logout-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_CYCLE_TIMEOUT, + g_param_spec_long ("cycle-timeout", + NULL, + NULL, + 10000, + G_MAXLONG, + 300000, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_THROTTLED, + g_param_spec_boolean ("throttled", + NULL, + NULL, + TRUE, + G_PARAM_READWRITE)); + + g_type_class_add_private (klass, sizeof (GSManagerPrivate)); +} + +static void +on_bg_changed (MateBG *bg, + GSManager *manager) +{ + gs_debug ("background changed"); +} + +static void +mateconf_changed_callback (MateConfClient *client, + guint cnxn_id, + MateConfEntry *entry, + GSManager *manager) +{ + mate_bg_load_from_preferences (manager->priv->bg, + manager->priv->client); +} + +static void +watch_bg_preferences (GSManager *manager) +{ + g_assert (manager->priv->bg_notify_id == 0); + + mateconf_client_add_dir (manager->priv->client, + MATE_BG_KEY_DIR, + MATECONF_CLIENT_PRELOAD_NONE, + NULL); + manager->priv->bg_notify_id = mateconf_client_notify_add (manager->priv->client, + MATE_BG_KEY_DIR, + (MateConfClientNotifyFunc)mateconf_changed_callback, + manager, + NULL, + NULL); +} + +static MateConfClient * +get_mateconf_client (void) +{ + MateConfClient *client; + GSList *addresses; + GError *error; + MateConfEngine *engine; + + client = NULL; + addresses = NULL; + + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.mandatory"); + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.system"); + addresses = g_slist_prepend (addresses, "xml:merged:" SYSCONFDIR "/mateconf/mateconf.xml.defaults"); + addresses = g_slist_reverse (addresses); + + error = NULL; + engine = mateconf_engine_get_for_addresses (addresses, &error); + if (engine == NULL) + { + gs_debug ("Unable to get mateconf engine for addresses: %s", error->message); + g_error_free (error); + } + else + { + client = mateconf_client_get_for_engine (engine); + } + + g_slist_free (addresses); + + return client; +} + +static void +gs_manager_init (GSManager *manager) +{ + manager->priv = GS_MANAGER_GET_PRIVATE (manager); + + manager->priv->fade = gs_fade_new (); + manager->priv->grab = gs_grab_new (); + manager->priv->theme_manager = gs_theme_manager_new (); + + manager->priv->client = get_mateconf_client (); + if (manager->priv->client != NULL) + { + manager->priv->bg = mate_bg_new (); + + g_signal_connect (manager->priv->bg, + "changed", + G_CALLBACK (on_bg_changed), + manager); + watch_bg_preferences (manager); + + mate_bg_load_from_preferences (manager->priv->bg, manager->priv->client); + } +} + +static void +remove_timers (GSManager *manager) +{ + remove_lock_timer (manager); + remove_cycle_timer (manager); +} + +static void +remove_unfade_idle (GSManager *manager) +{ + if (manager->priv->unfade_idle_id > 0) + { + g_source_remove (manager->priv->unfade_idle_id); + manager->priv->unfade_idle_id = 0; + } +} + + +static gboolean +window_deactivated_idle (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + /* don't deactivate directly but only emit a signal + so that we let the parent deactivate */ + g_signal_emit (manager, signals [DEACTIVATED], 0); + + return FALSE; +} + +static void +window_deactivated_cb (GSWindow *window, + GSManager *manager) +{ + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_idle_add ((GSourceFunc)window_deactivated_idle, manager); +} + +static GSWindow * +find_window_at_pointer (GSManager *manager) +{ + GdkDisplay *display; + GdkScreen *screen; + int monitor; + int x, y; + GSWindow *window; + int screen_num; + GSList *l; + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, &x, &y, NULL); + monitor = gdk_screen_get_monitor_at_point (screen, x, y); + screen_num = gdk_screen_get_number (screen); + + /* Find the gs-window that is on that screen */ + window = NULL; + for (l = manager->priv->windows; l; l = l->next) + { + GSWindow *win = GS_WINDOW (l->data); + if (gs_window_get_screen (win) == screen + && gs_window_get_monitor (win) == monitor) + { + window = win; + } + } + + if (window == NULL) + { + gs_debug ("WARNING: Could not find the GSWindow for screen %d", screen_num); + /* take the first one */ + window = manager->priv->windows->data; + } + else + { + gs_debug ("Requesting unlock for screen %d", screen_num); + } + + return window; +} + +void +gs_manager_show_message (GSManager *manager, + const char *summary, + const char *body, + const char *icon) +{ + GSWindow *window; + + g_return_if_fail (GS_IS_MANAGER (manager)); + + /* Find the GSWindow that contains the pointer */ + window = find_window_at_pointer (manager); + gs_window_show_message (window, summary, body, icon); + + gs_manager_request_unlock (manager); +} + +static gboolean +manager_maybe_grab_window (GSManager *manager, + GSWindow *window) +{ + GdkDisplay *display; + GdkScreen *screen; + int monitor; + int x, y; + gboolean grabbed; + + display = gdk_display_get_default (); + gdk_display_get_pointer (display, &screen, &x, &y, NULL); + monitor = gdk_screen_get_monitor_at_point (screen, x, y); + + gdk_flush (); + grabbed = FALSE; + if (gs_window_get_screen (window) == screen + && gs_window_get_monitor (window) == monitor) + { + gs_debug ("Moving grab to %p", window); + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + grabbed = TRUE; + } + + return grabbed; +} + +static void +window_grab_broken_cb (GSWindow *window, + GdkEventGrabBroken *event, + GSManager *manager) +{ + gs_debug ("GRAB BROKEN!"); + if (event->keyboard) + { + gs_grab_keyboard_reset (manager->priv->grab); + } + else + { + gs_grab_mouse_reset (manager->priv->grab); + } +} + +static gboolean +unfade_idle (GSManager *manager) +{ + gs_debug ("resetting fade"); + gs_fade_reset (manager->priv->fade); + manager->priv->unfade_idle_id = 0; + return FALSE; +} + + +static void +add_unfade_idle (GSManager *manager) +{ + remove_unfade_idle (manager); + manager->priv->unfade_idle_id = g_timeout_add (500, (GSourceFunc)unfade_idle, manager); +} + +static gboolean +window_map_event_cb (GSWindow *window, + GdkEvent *event, + GSManager *manager) +{ + gs_debug ("Handling window map_event event"); + + manager_maybe_grab_window (manager, window); + + manager_maybe_start_job_for_window (manager, window); + + return FALSE; +} + +static void +window_map_cb (GSWindow *window, + GSManager *manager) +{ + gs_debug ("Handling window map event"); +} + +static void +window_unmap_cb (GSWindow *window, + GSManager *manager) +{ + gs_debug ("window unmapped!"); +} + +static void +apply_background_to_window (GSManager *manager, + GSWindow *window) +{ + GdkPixmap *pixmap; + GdkScreen *screen; + int width; + int height; + + if (manager->priv->bg == NULL) + { + gs_debug ("No background available"); + gs_window_set_background_pixmap (window, NULL); + } + + screen = gs_window_get_screen (window); + width = gdk_screen_get_width (screen); + height = gdk_screen_get_height (screen); + gs_debug ("Creating pixmap background w:%d h:%d", width, height); + pixmap = mate_bg_create_pixmap (manager->priv->bg, + gs_window_get_gdk_window (window), + width, + height, + FALSE); + gs_window_set_background_pixmap (window, pixmap); + g_object_unref (pixmap); +} + +static void +manager_show_window (GSManager *manager, + GSWindow *window) +{ + GSJob *job; + + apply_background_to_window (manager, window); + + job = gs_job_new_for_widget (gs_window_get_drawing_area (window)); + + manager_select_theme_for_job (manager, job); + manager_add_job_for_window (manager, window, job); + + manager->priv->activate_time = time (NULL); + + if (manager->priv->lock_timeout >= 0) + { + remove_lock_timer (manager); + add_lock_timer (manager, manager->priv->lock_timeout); + } + + if (manager->priv->cycle_timeout >= 10000) + { + remove_cycle_timer (manager); + add_cycle_timer (manager, manager->priv->cycle_timeout); + } + + add_unfade_idle (manager); + + /* FIXME: only emit signal once */ + g_signal_emit (manager, signals [ACTIVATED], 0); +} + +static void +window_show_cb (GSWindow *window, + GSManager *manager) +{ + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + g_return_if_fail (window != NULL); + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Handling window show"); + manager_show_window (manager, window); +} + +static void +maybe_set_window_throttle (GSManager *manager, + GSWindow *window, + gboolean throttled) +{ + if (throttled) + { + manager_maybe_stop_job_for_window (manager, window); + } + else + { + manager_maybe_start_job_for_window (manager, window); + } +} + +static void +window_obscured_cb (GSWindow *window, + GParamSpec *pspec, + GSManager *manager) +{ + gboolean obscured; + + obscured = gs_window_is_obscured (window); + gs_debug ("Handling window obscured: %s", obscured ? "obscured" : "unobscured"); + + maybe_set_window_throttle (manager, window, obscured); + + if (! obscured) + { + gs_manager_request_unlock (manager); + } +} + +static void +handle_window_dialog_up (GSManager *manager, + GSWindow *window) +{ + GSList *l; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Handling dialog up"); + + g_signal_emit (manager, signals [AUTH_REQUEST_BEGIN], 0); + + manager->priv->dialog_up = TRUE; + /* Make all other windows insensitive so we don't get events */ + for (l = manager->priv->windows; l; l = l->next) + { + if (l->data != window) + { + gtk_widget_set_sensitive (GTK_WIDGET (l->data), FALSE); + } + } + + /* Move keyboard and mouse grabs so dialog can be used */ + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + + /* Release the pointer grab while dialog is up so that + the dialog can be used. We'll regrab it when the dialog goes down. */ + gs_grab_release_mouse (manager->priv->grab); + + if (! manager->priv->throttled) + { + gs_debug ("Suspending jobs"); + + manager_suspend_jobs (manager); + } +} + +static void +handle_window_dialog_down (GSManager *manager, + GSWindow *window) +{ + GSList *l; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + gs_debug ("Handling dialog down"); + + /* Regrab the mouse */ + gs_grab_move_to_window (manager->priv->grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + + /* Make all windows sensitive so we get events */ + for (l = manager->priv->windows; l; l = l->next) + { + gtk_widget_set_sensitive (GTK_WIDGET (l->data), TRUE); + } + + manager->priv->dialog_up = FALSE; + + if (! manager->priv->throttled) + { + manager_resume_jobs (manager); + } + + g_signal_emit (manager, signals [AUTH_REQUEST_END], 0); +} + +static void +window_dialog_up_changed_cb (GSWindow *window, + GParamSpec *pspec, + GSManager *manager) +{ + gboolean up; + + up = gs_window_is_dialog_up (window); + gs_debug ("Handling window dialog up changed: %s", up ? "up" : "down"); + if (up) + { + handle_window_dialog_up (manager, window); + } + else + { + handle_window_dialog_down (manager, window); + } +} + +static gboolean +window_activity_cb (GSWindow *window, + GSManager *manager) +{ + gboolean handled; + + handled = gs_manager_request_unlock (manager); + + return handled; +} + +static void +disconnect_window_signals (GSManager *manager, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (window, window_deactivated_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_activity_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_show_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_map_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_map_event_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_obscured_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_dialog_up_changed_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_unmap_cb, manager); + g_signal_handlers_disconnect_by_func (window, window_grab_broken_cb, manager); +} + +static void +window_destroyed_cb (GtkWindow *window, + GSManager *manager) +{ + disconnect_window_signals (manager, GS_WINDOW (window)); +} + +static void +connect_window_signals (GSManager *manager, + GSWindow *window) +{ + g_signal_connect_object (window, "destroy", + G_CALLBACK (window_destroyed_cb), manager, 0); + g_signal_connect_object (window, "activity", + G_CALLBACK (window_activity_cb), manager, 0); + g_signal_connect_object (window, "deactivated", + G_CALLBACK (window_deactivated_cb), manager, 0); + g_signal_connect_object (window, "show", + G_CALLBACK (window_show_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "map", + G_CALLBACK (window_map_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "map_event", + G_CALLBACK (window_map_event_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "notify::obscured", + G_CALLBACK (window_obscured_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "notify::dialog-up", + G_CALLBACK (window_dialog_up_changed_cb), manager, 0); + g_signal_connect_object (window, "unmap", + G_CALLBACK (window_unmap_cb), manager, G_CONNECT_AFTER); + g_signal_connect_object (window, "grab_broken_event", + G_CALLBACK (window_grab_broken_cb), manager, G_CONNECT_AFTER); +} + +static void +gs_manager_create_window_for_monitor (GSManager *manager, + GdkScreen *screen, + int monitor) +{ + GSWindow *window; + GdkRectangle rect; + + gdk_screen_get_monitor_geometry (screen, monitor, &rect); + + gs_debug ("Creating window for monitor %d [%d,%d] (%dx%d)", + monitor, rect.x, rect.y, rect.width, rect.height); + + window = gs_window_new (screen, monitor, manager->priv->lock_active); + + gs_window_set_user_switch_enabled (window, manager->priv->user_switch_enabled); + gs_window_set_logout_enabled (window, manager->priv->logout_enabled); + gs_window_set_logout_timeout (window, manager->priv->logout_timeout); + gs_window_set_logout_command (window, manager->priv->logout_command); + gs_window_set_keyboard_enabled (window, manager->priv->keyboard_enabled); + gs_window_set_keyboard_command (window, manager->priv->keyboard_command); + gs_window_set_status_message (window, manager->priv->status_message); + + connect_window_signals (manager, window); + + manager->priv->windows = g_slist_append (manager->priv->windows, window); + + if (manager->priv->active && !manager->priv->fading) + { + gtk_widget_show (GTK_WIDGET (window)); + } +} + +static void +on_screen_monitors_changed (GdkScreen *screen, + GSManager *manager) +{ + GSList *l; + int n_monitors; + int n_windows; + int i; + + n_monitors = gdk_screen_get_n_monitors (screen); + n_windows = g_slist_length (manager->priv->windows); + + gs_debug ("Monitors changed for screen %d: num=%d", + gdk_screen_get_number (screen), + n_monitors); + + if (n_monitors > n_windows) + { + + /* Tear down unlock dialog in case we want to move it + * to a new monitor + */ + l = manager->priv->windows; + while (l != NULL) + { + gs_window_cancel_unlock_request (GS_WINDOW (l->data)); + l = l->next; + } + + /* add more windows */ + for (i = n_windows; i < n_monitors; i++) + { + gs_manager_create_window_for_monitor (manager, screen, i); + } + + /* And put unlock dialog up where ever it's supposed to be + */ + gs_manager_request_unlock (manager); + } + else + { + + gdk_x11_grab_server (); + + /* remove the extra windows */ + l = manager->priv->windows; + while (l != NULL) + { + GdkScreen *this_screen; + int this_monitor; + GSList *next = l->next; + + this_screen = gs_window_get_screen (GS_WINDOW (l->data)); + this_monitor = gs_window_get_monitor (GS_WINDOW (l->data)); + if (this_screen == screen && this_monitor >= n_monitors) + { + manager_maybe_stop_job_for_window (manager, GS_WINDOW (l->data)); + g_hash_table_remove (manager->priv->jobs, l->data); + gs_window_destroy (GS_WINDOW (l->data)); + manager->priv->windows = g_slist_delete_link (manager->priv->windows, l); + } + l = next; + } + + /* make sure there is a lock dialog on a connected monitor, + * and that the keyboard is still properly grabbed after all + * the windows above got destroyed*/ + if (n_windows > n_monitors) + { + gs_manager_request_unlock (manager); + } + + gdk_flush (); + gdk_x11_ungrab_server (); + } +} + +static void +gs_manager_destroy_windows (GSManager *manager) +{ + GdkDisplay *display; + GSList *l; + int n_screens; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + if (manager->priv->windows == NULL) + { + return; + } + + display = gdk_display_get_default (); + + n_screens = gdk_display_get_n_screens (display); + + for (i = 0; i < n_screens; i++) + { + g_signal_handlers_disconnect_by_func (gdk_display_get_screen (display, i), + on_screen_monitors_changed, + manager); + } + + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_destroy (l->data); + } + g_slist_free (manager->priv->windows); + manager->priv->windows = NULL; +} + +static void +gs_manager_finalize (GObject *object) +{ + GSManager *manager; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_MANAGER (object)); + + manager = GS_MANAGER (object); + + g_return_if_fail (manager->priv != NULL); + + if (manager->priv->bg_notify_id != 0) + { + mateconf_client_remove_dir (manager->priv->client, + MATE_BG_KEY_DIR, + NULL); + mateconf_client_notify_remove (manager->priv->client, + manager->priv->bg_notify_id); + manager->priv->bg_notify_id = 0; + } + if (manager->priv->bg != NULL) + { + g_object_unref (manager->priv->bg); + } + if (manager->priv->client != NULL) + { + g_object_unref (manager->priv->client); + } + + free_themes (manager); + g_free (manager->priv->logout_command); + g_free (manager->priv->keyboard_command); + g_free (manager->priv->status_message); + + remove_unfade_idle (manager); + remove_timers (manager); + + gs_grab_release (manager->priv->grab); + + manager_stop_jobs (manager); + + gs_manager_destroy_windows (manager); + + manager->priv->active = FALSE; + manager->priv->activate_time = 0; + manager->priv->lock_enabled = FALSE; + + g_object_unref (manager->priv->fade); + g_object_unref (manager->priv->grab); + g_object_unref (manager->priv->theme_manager); + + G_OBJECT_CLASS (gs_manager_parent_class)->finalize (object); +} + +static void +gs_manager_create_windows_for_screen (GSManager *manager, + GdkScreen *screen) +{ + int n_monitors; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + g_return_if_fail (GDK_IS_SCREEN (screen)); + + g_object_ref (manager); + g_object_ref (screen); + + n_monitors = gdk_screen_get_n_monitors (screen); + + gs_debug ("Creating %d windows for screen %d", n_monitors, gdk_screen_get_number (screen)); + + for (i = 0; i < n_monitors; i++) + { + gs_manager_create_window_for_monitor (manager, screen, i); + } + + g_object_unref (screen); + g_object_unref (manager); +} + +static void +gs_manager_create_windows (GSManager *manager) +{ + GdkDisplay *display; + int n_screens; + int i; + + g_return_if_fail (manager != NULL); + g_return_if_fail (GS_IS_MANAGER (manager)); + + g_assert (manager->priv->windows == NULL); + + display = gdk_display_get_default (); + n_screens = gdk_display_get_n_screens (display); + + for (i = 0; i < n_screens; i++) + { + g_signal_connect (gdk_display_get_screen (display, i), + "monitors-changed", + G_CALLBACK (on_screen_monitors_changed), + manager); + + gs_manager_create_windows_for_screen (manager, gdk_display_get_screen (display, i)); + } +} + +GSManager * +gs_manager_new (void) +{ + GObject *manager; + + manager = g_object_new (GS_TYPE_MANAGER, NULL); + + return GS_MANAGER (manager); +} + +static void +show_windows (GSList *windows) +{ + GSList *l; + + for (l = windows; l; l = l->next) + { + gtk_widget_show (GTK_WIDGET (l->data)); + } +} + +static void +remove_job (GSJob *job) +{ + if (job == NULL) + { + return; + } + + gs_job_stop (job); + g_object_unref (job); +} + +static void +fade_done_cb (GSFade *fade, + GSManager *manager) +{ + gs_debug ("fade completed, showing windows"); + show_windows (manager->priv->windows); + manager->priv->fading = FALSE; +} + +static gboolean +gs_manager_activate (GSManager *manager) +{ + gboolean do_fade; + gboolean res; + + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (manager->priv->active) + { + gs_debug ("Trying to activate manager when already active"); + return FALSE; + } + + res = gs_grab_grab_root (manager->priv->grab, FALSE); + if (! res) + { + return FALSE; + } + + if (manager->priv->windows == NULL) + { + gs_manager_create_windows (GS_MANAGER (manager)); + } + + manager->priv->jobs = g_hash_table_new_full (g_direct_hash, + g_direct_equal, + NULL, + (GDestroyNotify)remove_job); + + manager->priv->active = TRUE; + + /* fade to black and show windows */ + do_fade = TRUE; + if (do_fade) + { + manager->priv->fading = TRUE; + gs_debug ("fading out"); + gs_fade_async (manager->priv->fade, + FADE_TIMEOUT, + (GSFadeDoneFunc)fade_done_cb, + manager); + + while (manager->priv->fading) + { + gtk_main_iteration (); + } + } + else + { + show_windows (manager->priv->windows); + } + + return TRUE; +} + +static gboolean +gs_manager_deactivate (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->active) + { + gs_debug ("Trying to deactivate a screensaver that is not active"); + return FALSE; + } + + remove_unfade_idle (manager); + gs_fade_reset (manager->priv->fade); + remove_timers (manager); + + gs_grab_release (manager->priv->grab); + + manager_stop_jobs (manager); + + gs_manager_destroy_windows (manager); + + /* reset state */ + manager->priv->active = FALSE; + manager->priv->activate_time = 0; + manager->priv->lock_active = FALSE; + manager->priv->dialog_up = FALSE; + manager->priv->fading = FALSE; + + return TRUE; +} + +gboolean +gs_manager_set_active (GSManager *manager, + gboolean active) +{ + gboolean res; + + if (active) + { + res = gs_manager_activate (manager); + } + else + { + res = gs_manager_deactivate (manager); + } + + return res; +} + +gboolean +gs_manager_get_active (GSManager *manager) +{ + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + return manager->priv->active; +} + +gboolean +gs_manager_request_unlock (GSManager *manager) +{ + GSWindow *window; + + g_return_val_if_fail (manager != NULL, FALSE); + g_return_val_if_fail (GS_IS_MANAGER (manager), FALSE); + + if (! manager->priv->active) + { + gs_debug ("Request unlock but manager is not active"); + return FALSE; + } + + if (manager->priv->dialog_up) + { + gs_debug ("Request unlock but dialog is already up"); + return FALSE; + } + + if (manager->priv->fading) + { + gs_debug ("Request unlock so finishing fade"); + gs_fade_finish (manager->priv->fade); + } + + if (manager->priv->windows == NULL) + { + gs_debug ("We don't have any windows!"); + return FALSE; + } + + /* Find the GSWindow that contains the pointer */ + window = find_window_at_pointer (manager); + gs_window_request_unlock (window); + + return TRUE; +} + +void +gs_manager_cancel_unlock_request (GSManager *manager) +{ + GSList *l; + for (l = manager->priv->windows; l; l = l->next) + { + gs_window_cancel_unlock_request (l->data); + } +} diff --git a/src/gs-manager.h b/src/gs-manager.h new file mode 100644 index 0000000..61e64b6 --- /dev/null +++ b/src/gs-manager.h @@ -0,0 +1,107 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_MANAGER_H +#define __GS_MANAGER_H + +#include "gs-prefs.h" + +G_BEGIN_DECLS + +#define GS_TYPE_MANAGER (gs_manager_get_type ()) +#define GS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_MANAGER, GSManager)) +#define GS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_MANAGER, GSManagerClass)) +#define GS_IS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_MANAGER)) +#define GS_IS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_MANAGER)) +#define GS_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_MANAGER, GSManagerClass)) + +typedef struct GSManagerPrivate GSManagerPrivate; + +typedef struct +{ + GObject parent; + GSManagerPrivate *priv; +} GSManager; + +typedef struct +{ + GObjectClass parent_class; + + void (* activated) (GSManager *manager); + void (* deactivated) (GSManager *manager); + void (* auth_request_begin) (GSManager *manager); + void (* auth_request_end) (GSManager *manager); + +} GSManagerClass; + +GType gs_manager_get_type (void); + +GSManager * gs_manager_new (void); + +gboolean gs_manager_set_active (GSManager *manager, + gboolean active); +gboolean gs_manager_get_active (GSManager *manager); + +gboolean gs_manager_cycle (GSManager *manager); + +void gs_manager_get_lock_active (GSManager *manager, + gboolean *lock_active); +void gs_manager_set_lock_active (GSManager *manager, + gboolean lock_active); +void gs_manager_set_keyboard_enabled (GSManager *manager, + gboolean enabled); +void gs_manager_set_keyboard_command (GSManager *manager, + const char *command); +void gs_manager_set_status_message (GSManager *manager, + const char *message); +void gs_manager_get_lock_enabled (GSManager *manager, + gboolean *lock_enabled); +void gs_manager_set_lock_enabled (GSManager *manager, + gboolean lock_enabled); +void gs_manager_set_lock_timeout (GSManager *manager, + glong lock_timeout); +void gs_manager_set_logout_enabled (GSManager *manager, + gboolean logout_enabled); +void gs_manager_set_user_switch_enabled (GSManager *manager, + gboolean user_switch_enabled); +void gs_manager_set_logout_timeout (GSManager *manager, + glong logout_timeout); +void gs_manager_set_logout_command (GSManager *manager, + const char *command); +void gs_manager_set_throttled (GSManager *manager, + gboolean lock_enabled); +void gs_manager_set_cycle_timeout (GSManager *manager, + glong cycle_timeout); +void gs_manager_set_themes (GSManager *manager, + GSList *themes); +void gs_manager_set_mode (GSManager *manager, + GSSaverMode mode); +void gs_manager_show_message (GSManager *manager, + const char *summary, + const char *body, + const char *icon); +gboolean gs_manager_request_unlock (GSManager *manager); +void gs_manager_cancel_unlock_request (GSManager *manager); + +G_END_DECLS + +#endif /* __GS_MANAGER_H */ diff --git a/src/gs-manager.h.orig b/src/gs-manager.h.orig new file mode 100644 index 0000000..6ef8db2 --- /dev/null +++ b/src/gs-manager.h.orig @@ -0,0 +1,107 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_MANAGER_H +#define __GS_MANAGER_H + +#include "gs-prefs.h" + +G_BEGIN_DECLS + +#define GS_TYPE_MANAGER (gs_manager_get_type ()) +#define GS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_MANAGER, GSManager)) +#define GS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_MANAGER, GSManagerClass)) +#define GS_IS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_MANAGER)) +#define GS_IS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_MANAGER)) +#define GS_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_MANAGER, GSManagerClass)) + +typedef struct GSManagerPrivate GSManagerPrivate; + +typedef struct +{ + GObject parent; + GSManagerPrivate *priv; +} GSManager; + +typedef struct +{ + GObjectClass parent_class; + + void (* activated) (GSManager *manager); + void (* deactivated) (GSManager *manager); + void (* auth_request_begin) (GSManager *manager); + void (* auth_request_end) (GSManager *manager); + +} GSManagerClass; + +GType gs_manager_get_type (void); + +GSManager * gs_manager_new (void); + +gboolean gs_manager_set_active (GSManager *manager, + gboolean active); +gboolean gs_manager_get_active (GSManager *manager); + +gboolean gs_manager_cycle (GSManager *manager); + +void gs_manager_get_lock_active (GSManager *manager, + gboolean *lock_active); +void gs_manager_set_lock_active (GSManager *manager, + gboolean lock_active); +void gs_manager_set_keyboard_enabled (GSManager *manager, + gboolean enabled); +void gs_manager_set_keyboard_command (GSManager *manager, + const char *command); +void gs_manager_set_status_message (GSManager *manager, + const char *message); +void gs_manager_get_lock_enabled (GSManager *manager, + gboolean *lock_enabled); +void gs_manager_set_lock_enabled (GSManager *manager, + gboolean lock_enabled); +void gs_manager_set_lock_timeout (GSManager *manager, + glong lock_timeout); +void gs_manager_set_logout_enabled (GSManager *manager, + gboolean logout_enabled); +void gs_manager_set_user_switch_enabled (GSManager *manager, + gboolean user_switch_enabled); +void gs_manager_set_logout_timeout (GSManager *manager, + glong logout_timeout); +void gs_manager_set_logout_command (GSManager *manager, + const char *command); +void gs_manager_set_throttled (GSManager *manager, + gboolean lock_enabled); +void gs_manager_set_cycle_timeout (GSManager *manager, + glong cycle_timeout); +void gs_manager_set_themes (GSManager *manager, + GSList *themes); +void gs_manager_set_mode (GSManager *manager, + GSSaverMode mode); +void gs_manager_show_message (GSManager *manager, + const char *summary, + const char *body, + const char *icon); +gboolean gs_manager_request_unlock (GSManager *manager); +void gs_manager_cancel_unlock_request (GSManager *manager); + +G_END_DECLS + +#endif /* __GS_MANAGER_H */ diff --git a/src/gs-marshal.list b/src/gs-marshal.list new file mode 100644 index 0000000..9a4d620 --- /dev/null +++ b/src/gs-marshal.list @@ -0,0 +1,4 @@ +BOOLEAN:VOID +BOOLEAN:INT +BOOLEAN:BOOLEAN +VOID:STRING,STRING,STRING diff --git a/src/gs-monitor.c b/src/gs-monitor.c new file mode 100644 index 0000000..2703ba3 --- /dev/null +++ b/src/gs-monitor.c @@ -0,0 +1,528 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include +#include + +#include "mate-screensaver.h" + +#include "gs-manager.h" +#include "gs-watcher.h" +#include "gs-fade.h" +#include "gs-grab.h" + +#include "gs-listener-dbus.h" +#include "gs-monitor.h" +#include "gs-prefs.h" +#include "gs-debug.h" + +static void gs_monitor_class_init (GSMonitorClass *klass); +static void gs_monitor_init (GSMonitor *monitor); +static void gs_monitor_finalize (GObject *object); + +#define GS_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_MONITOR, GSMonitorPrivate)) + +struct GSMonitorPrivate +{ + GSWatcher *watcher; + GSListener *listener; + GSManager *manager; + GSPrefs *prefs; + GSFade *fade; + GSGrab *grab; + guint release_grab_id; +}; + +#define FADE_TIMEOUT 10000 + +G_DEFINE_TYPE (GSMonitor, gs_monitor, G_TYPE_OBJECT) + +static void +gs_monitor_class_init (GSMonitorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_monitor_finalize; + + g_type_class_add_private (klass, sizeof (GSMonitorPrivate)); +} + +static void +manager_activated_cb (GSManager *manager, + GSMonitor *monitor) +{ +} + +static void +manager_deactivated_cb (GSManager *manager, + GSMonitor *monitor) +{ + gs_listener_set_active (monitor->priv->listener, FALSE); +} + +static gboolean +watcher_idle_cb (GSWatcher *watcher, + gboolean is_idle, + GSMonitor *monitor) +{ + gboolean res; + + gs_debug ("Idle signal detected: %d", is_idle); + + res = gs_listener_set_session_idle (monitor->priv->listener, is_idle); + + return res; +} + +static gboolean +release_grab_timeout (GSMonitor *monitor) +{ + gboolean manager_active; + + manager_active = gs_manager_get_active (monitor->priv->manager); + if (! manager_active) + { + gs_grab_release (monitor->priv->grab); + } + + monitor->priv->release_grab_id = 0; + return FALSE; +} + +static gboolean +watcher_idle_notice_cb (GSWatcher *watcher, + gboolean in_effect, + GSMonitor *monitor) +{ + gboolean activation_enabled; + gboolean inhibited; + gboolean handled; + + gs_debug ("Idle notice signal detected: %d", in_effect); + + /* only fade if screensaver can activate */ + activation_enabled = gs_listener_get_activation_enabled (monitor->priv->listener); + inhibited = gs_listener_is_inhibited (monitor->priv->listener); + + handled = FALSE; + if (in_effect) + { + if (activation_enabled && ! inhibited) + { + /* start slow fade */ + if (gs_grab_grab_offscreen (monitor->priv->grab, FALSE)) + { + gs_fade_async (monitor->priv->fade, FADE_TIMEOUT, NULL, NULL); + } + else + { + gs_debug ("Could not grab the keyboard so not performing idle warning fade-out"); + } + + handled = TRUE; + } + } + else + { + gboolean manager_active; + + manager_active = gs_manager_get_active (monitor->priv->manager); + /* cancel the fade unless manager was activated */ + if (! manager_active) + { + gs_debug ("manager not active, performing fade cancellation"); + gs_fade_reset (monitor->priv->fade); + + /* don't release the grab immediately to prevent typing passwords into windows */ + if (monitor->priv->release_grab_id != 0) + { + g_source_remove (monitor->priv->release_grab_id); + } + monitor->priv->release_grab_id = g_timeout_add (1000, (GSourceFunc)release_grab_timeout, monitor); + } + else + { + gs_debug ("manager active, skipping fade cancellation"); + } + + handled = TRUE; + } + + return handled; +} + +static void +gs_monitor_lock_screen (GSMonitor *monitor) +{ + gboolean res; + gboolean locked; + + /* set lock flag before trying to activate screensaver + in case something tries to react to the ActiveChanged signal */ + + gs_manager_get_lock_active (monitor->priv->manager, &locked); + gs_manager_set_lock_active (monitor->priv->manager, TRUE); + res = gs_listener_set_active (monitor->priv->listener, TRUE); + if (! res) + { + /* If we've failed then restore lock status */ + gs_manager_set_lock_active (monitor->priv->manager, locked); + gs_debug ("Unable to lock the screen"); + } +} + +static void +gs_monitor_simulate_user_activity (GSMonitor *monitor) +{ + /* FIXME: reset the xsync timer? */ + + /* request that the manager unlock - + will pop up a dialog if necessary */ + gs_manager_request_unlock (monitor->priv->manager); +} + +static void +listener_lock_cb (GSListener *listener, + GSMonitor *monitor) +{ + if (! monitor->priv->prefs->lock_disabled) + { + gs_monitor_lock_screen (monitor); + } + else + { + gs_debug ("Locking disabled by the administrator"); + } + +} + +static void +listener_quit_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_listener_set_active (monitor->priv->listener, FALSE); + mate_screensaver_quit (); +} + +static void +listener_cycle_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_manager_cycle (monitor->priv->manager); +} + +static void +listener_show_message_cb (GSListener *listener, + const char *summary, + const char *body, + const char *icon, + GSMonitor *monitor) +{ + gs_manager_show_message (monitor->priv->manager, + summary, + body, + icon); +} + +static gboolean +listener_active_changed_cb (GSListener *listener, + gboolean active, + GSMonitor *monitor) +{ + gboolean res; + gboolean ret; + gboolean idle_watch_enabled; + + res = gs_manager_set_active (monitor->priv->manager, active); + if (! res) + { + gs_debug ("Unable to set manager active: %d", active); + ret = FALSE; + goto done; + } + + ret = TRUE; + +done: + + idle_watch_enabled = gs_watcher_get_enabled (monitor->priv->watcher); + if (ret && idle_watch_enabled) + { + res = gs_watcher_set_active (monitor->priv->watcher, !active); + if (! res) + { + gs_debug ("Unable to set the idle watcher active: %d", !active); + } + } + + return ret; +} + +static void +listener_throttle_changed_cb (GSListener *listener, + gboolean throttled, + GSMonitor *monitor) +{ + gs_manager_set_throttled (monitor->priv->manager, throttled); +} + +static void +listener_simulate_user_activity_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_monitor_simulate_user_activity (monitor); +} + +static void +_gs_monitor_update_from_prefs (GSMonitor *monitor, + GSPrefs *prefs) +{ + gboolean idle_detection_enabled; + gboolean idle_detection_active; + gboolean activate_watch; + gboolean manager_active; + gboolean lock_enabled; + gboolean user_switch_enabled; + + lock_enabled = (monitor->priv->prefs->lock_enabled && !monitor->priv->prefs->lock_disabled); + user_switch_enabled = (monitor->priv->prefs->user_switch_enabled && !monitor->priv->prefs->user_switch_disabled); + + gs_manager_set_lock_enabled (monitor->priv->manager, lock_enabled); + gs_manager_set_lock_timeout (monitor->priv->manager, monitor->priv->prefs->lock_timeout); + gs_manager_set_logout_enabled (monitor->priv->manager, monitor->priv->prefs->logout_enabled); + gs_manager_set_user_switch_enabled (monitor->priv->manager, user_switch_enabled); + gs_manager_set_keyboard_enabled (monitor->priv->manager, monitor->priv->prefs->keyboard_enabled); + gs_manager_set_logout_timeout (monitor->priv->manager, monitor->priv->prefs->logout_timeout); + gs_manager_set_logout_command (monitor->priv->manager, monitor->priv->prefs->logout_command); + gs_manager_set_keyboard_command (monitor->priv->manager, monitor->priv->prefs->keyboard_command); + gs_manager_set_cycle_timeout (monitor->priv->manager, monitor->priv->prefs->cycle); + gs_manager_set_mode (monitor->priv->manager, monitor->priv->prefs->mode); + gs_manager_set_themes (monitor->priv->manager, monitor->priv->prefs->themes); + + /* enable activation when allowed */ + gs_listener_set_activation_enabled (monitor->priv->listener, + monitor->priv->prefs->idle_activation_enabled); + + /* idle detection always enabled */ + idle_detection_enabled = TRUE; + + gs_watcher_set_enabled (monitor->priv->watcher, idle_detection_enabled); + + /* in the case where idle detection is reenabled we may need to + activate the watcher too */ + + manager_active = gs_manager_get_active (monitor->priv->manager); + idle_detection_active = gs_watcher_get_active (monitor->priv->watcher); + activate_watch = (! manager_active + && ! idle_detection_active + && idle_detection_enabled); + if (activate_watch) + { + gs_watcher_set_active (monitor->priv->watcher, TRUE); + } + + if (monitor->priv->prefs->status_message_enabled) + { + char *text; + g_object_get (monitor->priv->watcher, + "status-message", &text, + NULL); + gs_manager_set_status_message (monitor->priv->manager, text); + g_free (text); + } + else + { + gs_manager_set_status_message (monitor->priv->manager, NULL); + } +} + +static void +disconnect_listener_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_lock_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_quit_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_cycle_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_active_changed_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_throttle_changed_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_simulate_user_activity_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_show_message_cb, monitor); +} + +static void +connect_listener_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->listener, "lock", + G_CALLBACK (listener_lock_cb), monitor); + g_signal_connect (monitor->priv->listener, "quit", + G_CALLBACK (listener_quit_cb), monitor); + g_signal_connect (monitor->priv->listener, "cycle", + G_CALLBACK (listener_cycle_cb), monitor); + g_signal_connect (monitor->priv->listener, "active-changed", + G_CALLBACK (listener_active_changed_cb), monitor); + g_signal_connect (monitor->priv->listener, "throttle-changed", + G_CALLBACK (listener_throttle_changed_cb), monitor); + g_signal_connect (monitor->priv->listener, "simulate-user-activity", + G_CALLBACK (listener_simulate_user_activity_cb), monitor); + g_signal_connect (monitor->priv->listener, "show-message", + G_CALLBACK (listener_show_message_cb), monitor); +} + +static void +on_watcher_status_message_changed (GSWatcher *watcher, + GParamSpec *pspec, + GSMonitor *monitor) +{ + char *text; + g_object_get (watcher, "status-message", &text, NULL); + gs_manager_set_status_message (monitor->priv->manager, text); + g_free (text); +} + +static void +disconnect_watcher_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, watcher_idle_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, watcher_idle_notice_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, on_watcher_status_message_changed, monitor); +} + +static void +connect_watcher_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->watcher, "idle-changed", + G_CALLBACK (watcher_idle_cb), monitor); + g_signal_connect (monitor->priv->watcher, "idle-notice-changed", + G_CALLBACK (watcher_idle_notice_cb), monitor); + g_signal_connect (monitor->priv->watcher, "notify::status-message", + G_CALLBACK (on_watcher_status_message_changed), monitor); + +} + +static void +disconnect_manager_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->manager, manager_activated_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->manager, manager_deactivated_cb, monitor); +} + +static void +connect_manager_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->manager, "activated", + G_CALLBACK (manager_activated_cb), monitor); + g_signal_connect (monitor->priv->manager, "deactivated", + G_CALLBACK (manager_deactivated_cb), monitor); +} + +static void +disconnect_prefs_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->prefs, _gs_monitor_update_from_prefs, monitor); +} + +static void +connect_prefs_signals (GSMonitor *monitor) +{ + g_signal_connect_swapped (monitor->priv->prefs, "changed", + G_CALLBACK (_gs_monitor_update_from_prefs), monitor); +} + +static void +gs_monitor_init (GSMonitor *monitor) +{ + + monitor->priv = GS_MONITOR_GET_PRIVATE (monitor); + + monitor->priv->prefs = gs_prefs_new (); + connect_prefs_signals (monitor); + + monitor->priv->listener = gs_listener_new (); + connect_listener_signals (monitor); + + monitor->priv->fade = gs_fade_new (); + monitor->priv->grab = gs_grab_new (); + + monitor->priv->watcher = gs_watcher_new (); + connect_watcher_signals (monitor); + + monitor->priv->manager = gs_manager_new (); + connect_manager_signals (monitor); + + _gs_monitor_update_from_prefs (monitor, monitor->priv->prefs); +} + +static void +gs_monitor_finalize (GObject *object) +{ + GSMonitor *monitor; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_MONITOR (object)); + + monitor = GS_MONITOR (object); + + g_return_if_fail (monitor->priv != NULL); + + disconnect_watcher_signals (monitor); + disconnect_listener_signals (monitor); + disconnect_manager_signals (monitor); + disconnect_prefs_signals (monitor); + + g_object_unref (monitor->priv->fade); + g_object_unref (monitor->priv->grab); + g_object_unref (monitor->priv->watcher); + g_object_unref (monitor->priv->listener); + g_object_unref (monitor->priv->manager); + g_object_unref (monitor->priv->prefs); + + G_OBJECT_CLASS (gs_monitor_parent_class)->finalize (object); +} + +GSMonitor * +gs_monitor_new (void) +{ + GSMonitor *monitor; + + monitor = g_object_new (GS_TYPE_MONITOR, NULL); + + return GS_MONITOR (monitor); +} + +gboolean +gs_monitor_start (GSMonitor *monitor, + GError **error) +{ + g_return_val_if_fail (GS_IS_MONITOR (monitor), FALSE); + + if (! gs_listener_acquire (monitor->priv->listener, error)) + { + return FALSE; + } + + return TRUE; +} diff --git a/src/gs-monitor.c.orig b/src/gs-monitor.c.orig new file mode 100644 index 0000000..c8478a4 --- /dev/null +++ b/src/gs-monitor.c.orig @@ -0,0 +1,528 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include +#include + +#include "mate-screensaver.h" + +#include "gs-manager.h" +#include "gs-watcher.h" +#include "gs-fade.h" +#include "gs-grab.h" + +#include "gs-listener-dbus.h" +#include "gs-monitor.h" +#include "gs-prefs.h" +#include "gs-debug.h" + +static void gs_monitor_class_init (GSMonitorClass *klass); +static void gs_monitor_init (GSMonitor *monitor); +static void gs_monitor_finalize (GObject *object); + +#define GS_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_MONITOR, GSMonitorPrivate)) + +struct GSMonitorPrivate +{ + GSWatcher *watcher; + GSListener *listener; + GSManager *manager; + GSPrefs *prefs; + GSFade *fade; + GSGrab *grab; + guint release_grab_id; +}; + +#define FADE_TIMEOUT 10000 + +G_DEFINE_TYPE (GSMonitor, gs_monitor, G_TYPE_OBJECT) + +static void +gs_monitor_class_init (GSMonitorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_monitor_finalize; + + g_type_class_add_private (klass, sizeof (GSMonitorPrivate)); +} + +static void +manager_activated_cb (GSManager *manager, + GSMonitor *monitor) +{ +} + +static void +manager_deactivated_cb (GSManager *manager, + GSMonitor *monitor) +{ + gs_listener_set_active (monitor->priv->listener, FALSE); +} + +static gboolean +watcher_idle_cb (GSWatcher *watcher, + gboolean is_idle, + GSMonitor *monitor) +{ + gboolean res; + + gs_debug ("Idle signal detected: %d", is_idle); + + res = gs_listener_set_session_idle (monitor->priv->listener, is_idle); + + return res; +} + +static gboolean +release_grab_timeout (GSMonitor *monitor) +{ + gboolean manager_active; + + manager_active = gs_manager_get_active (monitor->priv->manager); + if (! manager_active) + { + gs_grab_release (monitor->priv->grab); + } + + monitor->priv->release_grab_id = 0; + return FALSE; +} + +static gboolean +watcher_idle_notice_cb (GSWatcher *watcher, + gboolean in_effect, + GSMonitor *monitor) +{ + gboolean activation_enabled; + gboolean inhibited; + gboolean handled; + + gs_debug ("Idle notice signal detected: %d", in_effect); + + /* only fade if screensaver can activate */ + activation_enabled = gs_listener_get_activation_enabled (monitor->priv->listener); + inhibited = gs_listener_is_inhibited (monitor->priv->listener); + + handled = FALSE; + if (in_effect) + { + if (activation_enabled && ! inhibited) + { + /* start slow fade */ + if (gs_grab_grab_offscreen (monitor->priv->grab, FALSE)) + { + gs_fade_async (monitor->priv->fade, FADE_TIMEOUT, NULL, NULL); + } + else + { + gs_debug ("Could not grab the keyboard so not performing idle warning fade-out"); + } + + handled = TRUE; + } + } + else + { + gboolean manager_active; + + manager_active = gs_manager_get_active (monitor->priv->manager); + /* cancel the fade unless manager was activated */ + if (! manager_active) + { + gs_debug ("manager not active, performing fade cancellation"); + gs_fade_reset (monitor->priv->fade); + + /* don't release the grab immediately to prevent typing passwords into windows */ + if (monitor->priv->release_grab_id != 0) + { + g_source_remove (monitor->priv->release_grab_id); + } + monitor->priv->release_grab_id = g_timeout_add (1000, (GSourceFunc)release_grab_timeout, monitor); + } + else + { + gs_debug ("manager active, skipping fade cancellation"); + } + + handled = TRUE; + } + + return handled; +} + +static void +gs_monitor_lock_screen (GSMonitor *monitor) +{ + gboolean res; + gboolean locked; + + /* set lock flag before trying to activate screensaver + in case something tries to react to the ActiveChanged signal */ + + gs_manager_get_lock_active (monitor->priv->manager, &locked); + gs_manager_set_lock_active (monitor->priv->manager, TRUE); + res = gs_listener_set_active (monitor->priv->listener, TRUE); + if (! res) + { + /* If we've failed then restore lock status */ + gs_manager_set_lock_active (monitor->priv->manager, locked); + gs_debug ("Unable to lock the screen"); + } +} + +static void +gs_monitor_simulate_user_activity (GSMonitor *monitor) +{ + /* FIXME: reset the xsync timer? */ + + /* request that the manager unlock - + will pop up a dialog if necessary */ + gs_manager_request_unlock (monitor->priv->manager); +} + +static void +listener_lock_cb (GSListener *listener, + GSMonitor *monitor) +{ + if (! monitor->priv->prefs->lock_disabled) + { + gs_monitor_lock_screen (monitor); + } + else + { + gs_debug ("Locking disabled by the administrator"); + } + +} + +static void +listener_quit_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_listener_set_active (monitor->priv->listener, FALSE); + mate_screensaver_quit (); +} + +static void +listener_cycle_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_manager_cycle (monitor->priv->manager); +} + +static void +listener_show_message_cb (GSListener *listener, + const char *summary, + const char *body, + const char *icon, + GSMonitor *monitor) +{ + gs_manager_show_message (monitor->priv->manager, + summary, + body, + icon); +} + +static gboolean +listener_active_changed_cb (GSListener *listener, + gboolean active, + GSMonitor *monitor) +{ + gboolean res; + gboolean ret; + gboolean idle_watch_enabled; + + res = gs_manager_set_active (monitor->priv->manager, active); + if (! res) + { + gs_debug ("Unable to set manager active: %d", active); + ret = FALSE; + goto done; + } + + ret = TRUE; + +done: + + idle_watch_enabled = gs_watcher_get_enabled (monitor->priv->watcher); + if (ret && idle_watch_enabled) + { + res = gs_watcher_set_active (monitor->priv->watcher, !active); + if (! res) + { + gs_debug ("Unable to set the idle watcher active: %d", !active); + } + } + + return ret; +} + +static void +listener_throttle_changed_cb (GSListener *listener, + gboolean throttled, + GSMonitor *monitor) +{ + gs_manager_set_throttled (monitor->priv->manager, throttled); +} + +static void +listener_simulate_user_activity_cb (GSListener *listener, + GSMonitor *monitor) +{ + gs_monitor_simulate_user_activity (monitor); +} + +static void +_gs_monitor_update_from_prefs (GSMonitor *monitor, + GSPrefs *prefs) +{ + gboolean idle_detection_enabled; + gboolean idle_detection_active; + gboolean activate_watch; + gboolean manager_active; + gboolean lock_enabled; + gboolean user_switch_enabled; + + lock_enabled = (monitor->priv->prefs->lock_enabled && !monitor->priv->prefs->lock_disabled); + user_switch_enabled = (monitor->priv->prefs->user_switch_enabled && !monitor->priv->prefs->user_switch_disabled); + + gs_manager_set_lock_enabled (monitor->priv->manager, lock_enabled); + gs_manager_set_lock_timeout (monitor->priv->manager, monitor->priv->prefs->lock_timeout); + gs_manager_set_logout_enabled (monitor->priv->manager, monitor->priv->prefs->logout_enabled); + gs_manager_set_user_switch_enabled (monitor->priv->manager, user_switch_enabled); + gs_manager_set_keyboard_enabled (monitor->priv->manager, monitor->priv->prefs->keyboard_enabled); + gs_manager_set_logout_timeout (monitor->priv->manager, monitor->priv->prefs->logout_timeout); + gs_manager_set_logout_command (monitor->priv->manager, monitor->priv->prefs->logout_command); + gs_manager_set_keyboard_command (monitor->priv->manager, monitor->priv->prefs->keyboard_command); + gs_manager_set_cycle_timeout (monitor->priv->manager, monitor->priv->prefs->cycle); + gs_manager_set_mode (monitor->priv->manager, monitor->priv->prefs->mode); + gs_manager_set_themes (monitor->priv->manager, monitor->priv->prefs->themes); + + /* enable activation when allowed */ + gs_listener_set_activation_enabled (monitor->priv->listener, + monitor->priv->prefs->idle_activation_enabled); + + /* idle detection always enabled */ + idle_detection_enabled = TRUE; + + gs_watcher_set_enabled (monitor->priv->watcher, idle_detection_enabled); + + /* in the case where idle detection is reenabled we may need to + activate the watcher too */ + + manager_active = gs_manager_get_active (monitor->priv->manager); + idle_detection_active = gs_watcher_get_active (monitor->priv->watcher); + activate_watch = (! manager_active + && ! idle_detection_active + && idle_detection_enabled); + if (activate_watch) + { + gs_watcher_set_active (monitor->priv->watcher, TRUE); + } + + if (monitor->priv->prefs->status_message_enabled) + { + char *text; + g_object_get (monitor->priv->watcher, + "status-message", &text, + NULL); + gs_manager_set_status_message (monitor->priv->manager, text); + g_free (text); + } + else + { + gs_manager_set_status_message (monitor->priv->manager, NULL); + } +} + +static void +disconnect_listener_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_lock_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_quit_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_cycle_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_active_changed_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_throttle_changed_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_simulate_user_activity_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->listener, listener_show_message_cb, monitor); +} + +static void +connect_listener_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->listener, "lock", + G_CALLBACK (listener_lock_cb), monitor); + g_signal_connect (monitor->priv->listener, "quit", + G_CALLBACK (listener_quit_cb), monitor); + g_signal_connect (monitor->priv->listener, "cycle", + G_CALLBACK (listener_cycle_cb), monitor); + g_signal_connect (monitor->priv->listener, "active-changed", + G_CALLBACK (listener_active_changed_cb), monitor); + g_signal_connect (monitor->priv->listener, "throttle-changed", + G_CALLBACK (listener_throttle_changed_cb), monitor); + g_signal_connect (monitor->priv->listener, "simulate-user-activity", + G_CALLBACK (listener_simulate_user_activity_cb), monitor); + g_signal_connect (monitor->priv->listener, "show-message", + G_CALLBACK (listener_show_message_cb), monitor); +} + +static void +on_watcher_status_message_changed (GSWatcher *watcher, + GParamSpec *pspec, + GSMonitor *monitor) +{ + char *text; + g_object_get (watcher, "status-message", &text, NULL); + gs_manager_set_status_message (monitor->priv->manager, text); + g_free (text); +} + +static void +disconnect_watcher_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, watcher_idle_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, watcher_idle_notice_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->watcher, on_watcher_status_message_changed, monitor); +} + +static void +connect_watcher_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->watcher, "idle-changed", + G_CALLBACK (watcher_idle_cb), monitor); + g_signal_connect (monitor->priv->watcher, "idle-notice-changed", + G_CALLBACK (watcher_idle_notice_cb), monitor); + g_signal_connect (monitor->priv->watcher, "notify::status-message", + G_CALLBACK (on_watcher_status_message_changed), monitor); + +} + +static void +disconnect_manager_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->manager, manager_activated_cb, monitor); + g_signal_handlers_disconnect_by_func (monitor->priv->manager, manager_deactivated_cb, monitor); +} + +static void +connect_manager_signals (GSMonitor *monitor) +{ + g_signal_connect (monitor->priv->manager, "activated", + G_CALLBACK (manager_activated_cb), monitor); + g_signal_connect (monitor->priv->manager, "deactivated", + G_CALLBACK (manager_deactivated_cb), monitor); +} + +static void +disconnect_prefs_signals (GSMonitor *monitor) +{ + g_signal_handlers_disconnect_by_func (monitor->priv->prefs, _gs_monitor_update_from_prefs, monitor); +} + +static void +connect_prefs_signals (GSMonitor *monitor) +{ + g_signal_connect_swapped (monitor->priv->prefs, "changed", + G_CALLBACK (_gs_monitor_update_from_prefs), monitor); +} + +static void +gs_monitor_init (GSMonitor *monitor) +{ + + monitor->priv = GS_MONITOR_GET_PRIVATE (monitor); + + monitor->priv->prefs = gs_prefs_new (); + connect_prefs_signals (monitor); + + monitor->priv->listener = gs_listener_new (); + connect_listener_signals (monitor); + + monitor->priv->fade = gs_fade_new (); + monitor->priv->grab = gs_grab_new (); + + monitor->priv->watcher = gs_watcher_new (); + connect_watcher_signals (monitor); + + monitor->priv->manager = gs_manager_new (); + connect_manager_signals (monitor); + + _gs_monitor_update_from_prefs (monitor, monitor->priv->prefs); +} + +static void +gs_monitor_finalize (GObject *object) +{ + GSMonitor *monitor; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_MONITOR (object)); + + monitor = GS_MONITOR (object); + + g_return_if_fail (monitor->priv != NULL); + + disconnect_watcher_signals (monitor); + disconnect_listener_signals (monitor); + disconnect_manager_signals (monitor); + disconnect_prefs_signals (monitor); + + g_object_unref (monitor->priv->fade); + g_object_unref (monitor->priv->grab); + g_object_unref (monitor->priv->watcher); + g_object_unref (monitor->priv->listener); + g_object_unref (monitor->priv->manager); + g_object_unref (monitor->priv->prefs); + + G_OBJECT_CLASS (gs_monitor_parent_class)->finalize (object); +} + +GSMonitor * +gs_monitor_new (void) +{ + GSMonitor *monitor; + + monitor = g_object_new (GS_TYPE_MONITOR, NULL); + + return GS_MONITOR (monitor); +} + +gboolean +gs_monitor_start (GSMonitor *monitor, + GError **error) +{ + g_return_val_if_fail (GS_IS_MONITOR (monitor), FALSE); + + if (! gs_listener_acquire (monitor->priv->listener, error)) + { + return FALSE; + } + + return TRUE; +} diff --git a/src/gs-monitor.h b/src/gs-monitor.h new file mode 100644 index 0000000..6acc18c --- /dev/null +++ b/src/gs-monitor.h @@ -0,0 +1,57 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_MONITOR_H +#define __GS_MONITOR_H + +G_BEGIN_DECLS + +#define GS_TYPE_MONITOR (gs_monitor_get_type ()) +#define GS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_MONITOR, GSMonitor)) +#define GS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_MONITOR, GSMonitorClass)) +#define GS_IS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_MONITOR)) +#define GS_IS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_MONITOR)) +#define GS_MONITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_MONITOR, GSMonitorClass)) + +typedef struct GSMonitorPrivate GSMonitorPrivate; + +typedef struct +{ + GObject parent; + GSMonitorPrivate *priv; +} GSMonitor; + +typedef struct +{ + GObjectClass parent_class; +} GSMonitorClass; + +GType gs_monitor_get_type (void); + +GSMonitor * gs_monitor_new (void); +gboolean gs_monitor_start (GSMonitor *monitor, + GError **error); +void gs_monitor_set_lock_enabled (GSMonitor *monitor, + gboolean lock_enabled); +G_END_DECLS + +#endif /* __GS_MONITOR_H */ diff --git a/src/gs-monitor.h.orig b/src/gs-monitor.h.orig new file mode 100644 index 0000000..8ab3b0d --- /dev/null +++ b/src/gs-monitor.h.orig @@ -0,0 +1,57 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_MONITOR_H +#define __GS_MONITOR_H + +G_BEGIN_DECLS + +#define GS_TYPE_MONITOR (gs_monitor_get_type ()) +#define GS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_MONITOR, GSMonitor)) +#define GS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_MONITOR, GSMonitorClass)) +#define GS_IS_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_MONITOR)) +#define GS_IS_MONITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_MONITOR)) +#define GS_MONITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_MONITOR, GSMonitorClass)) + +typedef struct GSMonitorPrivate GSMonitorPrivate; + +typedef struct +{ + GObject parent; + GSMonitorPrivate *priv; +} GSMonitor; + +typedef struct +{ + GObjectClass parent_class; +} GSMonitorClass; + +GType gs_monitor_get_type (void); + +GSMonitor * gs_monitor_new (void); +gboolean gs_monitor_start (GSMonitor *monitor, + GError **error); +void gs_monitor_set_lock_enabled (GSMonitor *monitor, + gboolean lock_enabled); +G_END_DECLS + +#endif /* __GS_MONITOR_H */ diff --git a/src/gs-prefs.c b/src/gs-prefs.c new file mode 100644 index 0000000..0f9d14e --- /dev/null +++ b/src/gs-prefs.c @@ -0,0 +1,995 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include +#include + +#include "gs-prefs.h" + +static void gs_prefs_class_init (GSPrefsClass *klass); +static void gs_prefs_init (GSPrefs *prefs); +static void gs_prefs_finalize (GObject *object); + +#define MATE_LOCKDOWN_DIR "/desktop/mate/lockdown" +#define KEY_LOCK_DISABLE MATE_LOCKDOWN_DIR "/disable_lock_screen" +#define KEY_USER_SWITCH_DISABLE MATE_LOCKDOWN_DIR "/disable_user_switching" + +#define KEY_DIR "/apps/mate-screensaver" +#define MATE_SESSION_DIR "/desktop/mate/session" +#define KEY_IDLE_ACTIVATION_ENABLED KEY_DIR "/idle_activation_enabled" +#define KEY_LOCK_ENABLED KEY_DIR "/lock_enabled" +#define KEY_MODE KEY_DIR "/mode" +#define KEY_ACTIVATE_DELAY MATE_SESSION_DIR "/idle_delay" +#define KEY_POWER_DELAY KEY_DIR "/power_management_delay" +#define KEY_LOCK_DELAY KEY_DIR "/lock_delay" +#define KEY_CYCLE_DELAY KEY_DIR "/cycle_delay" +#define KEY_THEMES KEY_DIR "/themes" +#define KEY_USER_SWITCH_ENABLED KEY_DIR "/user_switch_enabled" +#define KEY_LOGOUT_ENABLED KEY_DIR "/logout_enabled" +#define KEY_LOGOUT_DELAY KEY_DIR "/logout_delay" +#define KEY_LOGOUT_COMMAND KEY_DIR "/logout_command" +#define KEY_KEYBOARD_ENABLED KEY_DIR "/embedded_keyboard_enabled" +#define KEY_KEYBOARD_COMMAND KEY_DIR "/embedded_keyboard_command" +#define KEY_STATUS_MESSAGE_ENABLED KEY_DIR "/status_message_enabled" + +#define GS_PREFS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_PREFS, GSPrefsPrivate)) + +struct GSPrefsPrivate +{ + MateConfClient *mateconf_client; +}; + +enum +{ + CHANGED, + LAST_SIGNAL +}; + +enum +{ + PROP_0 +}; + +static MateConfEnumStringPair mode_enum_map [] = +{ + { GS_MODE_BLANK_ONLY, "blank-only" }, + { GS_MODE_RANDOM, "random" }, + { GS_MODE_SINGLE, "single" }, + { 0, NULL } +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSPrefs, gs_prefs, G_TYPE_OBJECT) + +static void +gs_prefs_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_prefs_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_prefs_class_init (GSPrefsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_prefs_finalize; + object_class->get_property = gs_prefs_get_property; + object_class->set_property = gs_prefs_set_property; + + + signals [CHANGED] = + g_signal_new ("changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSPrefsClass, changed), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_type_class_add_private (klass, sizeof (GSPrefsPrivate)); + +} + +static void +_gs_prefs_set_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 10; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->timeout = value * 60000; +} + +static void +_gs_prefs_set_power_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 60; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + /* this value is in seconds - others are in minutes */ + prefs->power_timeout = value * 1000; +} + +static void +_gs_prefs_set_lock_timeout (GSPrefs *prefs, + int value) +{ + if (value < 0) + value = 0; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->lock_timeout = value * 60000; +} + +static void +_gs_prefs_set_cycle_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 1; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->cycle = value * 60000; +} + +static void +_gs_prefs_set_mode (GSPrefs *prefs, + const char *value) +{ + int mode; + + if (value && mateconf_string_to_enum (mode_enum_map, value, &mode)) + prefs->mode = mode; + else + prefs->mode = GS_MODE_BLANK_ONLY; +} + +static void +_gs_prefs_set_themes (GSPrefs *prefs, + GSList *list) +{ + if (prefs->themes) + { + g_slist_foreach (prefs->themes, (GFunc)g_free, NULL); + g_slist_free (prefs->themes); + } + + /* take ownership of the list */ + prefs->themes = list; +} + +static void +_gs_prefs_set_idle_activation_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->idle_activation_enabled = value; +} + +static void +_gs_prefs_set_lock_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->lock_enabled = value; +} + +static void +_gs_prefs_set_lock_disabled (GSPrefs *prefs, + gboolean value) +{ + prefs->lock_disabled = value; +} + +static void +_gs_prefs_set_user_switch_disabled (GSPrefs *prefs, + gboolean value) +{ + prefs->user_switch_disabled = value; +} + +static void +_gs_prefs_set_keyboard_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->keyboard_enabled = value; +} + +static void +_gs_prefs_set_keyboard_command (GSPrefs *prefs, + const char *value) +{ + g_free (prefs->keyboard_command); + prefs->keyboard_command = NULL; + + if (value) + { + /* FIXME: check command */ + + prefs->keyboard_command = g_strdup (value); + } +} + +static void +_gs_prefs_set_status_message_enabled (GSPrefs *prefs, + gboolean enabled) +{ + prefs->status_message_enabled = enabled; +} + +static void +_gs_prefs_set_logout_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->logout_enabled = value; +} + +static void +_gs_prefs_set_logout_command (GSPrefs *prefs, + const char *value) +{ + g_free (prefs->logout_command); + prefs->logout_command = NULL; + + if (value) + { + /* FIXME: check command */ + + prefs->logout_command = g_strdup (value); + } +} + +static void +_gs_prefs_set_logout_timeout (GSPrefs *prefs, + int value) +{ + if (value < 0) + value = 0; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->logout_timeout = value * 60000; +} + +static void +_gs_prefs_set_user_switch_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->user_switch_enabled = value; +} + +static void +key_error_and_free (const char *key, + GError *error) +{ + g_warning ("Error retrieving configuration key '%s': %s", key, error->message); + g_error_free (error); + error = NULL; +} + +static void +gs_prefs_load_from_mateconf (GSPrefs *prefs) +{ + glong value; + gboolean bvalue; + char *string; + GSList *list; + GError *error; + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_IDLE_ACTIVATION_ENABLED, &error); + if (! error) + { + _gs_prefs_set_idle_activation_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_IDLE_ACTIVATION_ENABLED, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOCK_ENABLED, &error); + if (! error) + { + _gs_prefs_set_lock_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOCK_ENABLED, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOCK_DISABLE, &error); + if (! error) + { + _gs_prefs_set_lock_disabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOCK_DISABLE, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_USER_SWITCH_DISABLE, &error); + if (! error) + { + _gs_prefs_set_user_switch_disabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_USER_SWITCH_DISABLE, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_ACTIVATE_DELAY, &error); + if (! error) + { + _gs_prefs_set_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_ACTIVATE_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_POWER_DELAY, &error); + if (! error) + { + _gs_prefs_set_power_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_POWER_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_LOCK_DELAY, &error); + if (! error) + { + _gs_prefs_set_lock_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_LOCK_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_CYCLE_DELAY, &error); + if (! error) + { + _gs_prefs_set_cycle_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_CYCLE_DELAY, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_MODE, &error); + if (! error) + { + _gs_prefs_set_mode (prefs, string); + } + else + { + key_error_and_free (KEY_MODE, error); + } + g_free (string); + + error = NULL; + list = mateconf_client_get_list (prefs->priv->mateconf_client, + KEY_THEMES, + MATECONF_VALUE_STRING, + &error); + if (! error) + { + _gs_prefs_set_themes (prefs, list); + } + else + { + key_error_and_free (KEY_THEMES, error); + } + + /* Embedded keyboard options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_KEYBOARD_ENABLED, &error); + if (! error) + { + _gs_prefs_set_keyboard_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_KEYBOARD_ENABLED, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_KEYBOARD_COMMAND, &error); + if (! error) + { + _gs_prefs_set_keyboard_command (prefs, string); + } + else + { + key_error_and_free (KEY_KEYBOARD_COMMAND, error); + } + g_free (string); + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_STATUS_MESSAGE_ENABLED, &error); + if (! error) + { + _gs_prefs_set_status_message_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_STATUS_MESSAGE_ENABLED, error); + } + + /* Logout options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOGOUT_ENABLED, &error); + if (! error) + { + _gs_prefs_set_logout_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOGOUT_ENABLED, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_LOGOUT_COMMAND, &error); + if (! error) + { + _gs_prefs_set_logout_command (prefs, string); + } + else + { + key_error_and_free (KEY_LOGOUT_COMMAND, error); + } + g_free (string); + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_LOGOUT_DELAY, &error); + if (! error) + { + _gs_prefs_set_logout_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_LOGOUT_DELAY, error); + } + + /* User switching options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_USER_SWITCH_ENABLED, &error); + if (! error) + { + _gs_prefs_set_user_switch_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_USER_SWITCH_ENABLED, error); + } +} + +static void +invalid_type_warning (const char *type) +{ + g_warning ("Error retrieving configuration key '%s': Invalid type", + type); +} + +static void +key_changed_cb (MateConfClient *client, + guint cnxn_id, + MateConfEntry *entry, + GSPrefs *prefs) +{ + gboolean changed = FALSE; + 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_MODE) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *str; + + str = mateconf_value_get_string (value); + _gs_prefs_set_mode (prefs, str); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_THEMES) == 0) + { + GSList *list = NULL; + + if (value == NULL + || value->type != MATECONF_VALUE_LIST) + { + return; + } + + list = mateconf_value_get_list (value); + + if (list + && mateconf_value_get_list_type (value) == MATECONF_VALUE_STRING) + { + GSList *l; + GSList *new_list; + + changed = TRUE; + + new_list = NULL; + for (l = list; l; l = l->next) + { + char *s; + + s = mateconf_value_to_string (l->data); + + new_list = g_slist_prepend (new_list, g_strdup (s)); + + g_free (s); + } + + new_list = g_slist_reverse (new_list); + + _gs_prefs_set_themes (prefs, new_list); + + } + + } + else if (strcmp (key, KEY_ACTIVATE_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_POWER_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_power_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOCK_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_lock_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_idle_activation_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOCK_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_lock_enabled (prefs, enabled); + + changed = TRUE; + } + 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); + _gs_prefs_set_lock_disabled (prefs, disabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_USER_SWITCH_DISABLE) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean disabled; + + disabled = mateconf_value_get_bool (value); + _gs_prefs_set_user_switch_disabled (prefs, disabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_CYCLE_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_cycle_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_KEYBOARD_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_keyboard_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_KEYBOARD_COMMAND) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *command; + + command = mateconf_value_get_string (value); + _gs_prefs_set_keyboard_command (prefs, command); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_STATUS_MESSAGE_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_status_message_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_logout_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_logout_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_COMMAND) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *command; + + command = mateconf_value_get_string (value); + _gs_prefs_set_logout_command (prefs, command); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_USER_SWITCH_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_user_switch_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else + { + g_warning ("Config key not handled: %s", key); + } + + if (changed && prefs) + { + g_signal_emit (prefs, signals [CHANGED], 0); + } +} + +static void +gs_prefs_init (GSPrefs *prefs) +{ + prefs->priv = GS_PREFS_GET_PRIVATE (prefs); + + prefs->priv->mateconf_client = mateconf_client_get_default (); + + prefs->idle_activation_enabled = TRUE; + prefs->lock_enabled = TRUE; + prefs->lock_disabled = FALSE; + prefs->logout_enabled = FALSE; + prefs->user_switch_enabled = FALSE; + + prefs->timeout = 600000; + prefs->power_timeout = 60000; + prefs->lock_timeout = 0; + prefs->logout_timeout = 14400000; + prefs->cycle = 600000; + + prefs->mode = GS_MODE_SINGLE; + + /* MateConf setup */ + mateconf_client_add_dir (prefs->priv->mateconf_client, + KEY_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + mateconf_client_add_dir (prefs->priv->mateconf_client, + MATE_LOCKDOWN_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + mateconf_client_add_dir (prefs->priv->mateconf_client, + MATE_SESSION_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + + + mateconf_client_notify_add (prefs->priv->mateconf_client, + KEY_DIR, + (MateConfClientNotifyFunc)key_changed_cb, + prefs, + NULL, NULL); + mateconf_client_notify_add (prefs->priv->mateconf_client, + MATE_LOCKDOWN_DIR, + (MateConfClientNotifyFunc)key_changed_cb, + prefs, + NULL, NULL); + + gs_prefs_load_from_mateconf (prefs); +} + +static void +gs_prefs_finalize (GObject *object) +{ + GSPrefs *prefs; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_PREFS (object)); + + prefs = GS_PREFS (object); + + g_return_if_fail (prefs->priv != NULL); + + if (prefs->priv->mateconf_client) + { + g_object_unref (prefs->priv->mateconf_client); + prefs->priv->mateconf_client = NULL; + } + + if (prefs->themes) + { + g_slist_foreach (prefs->themes, (GFunc)g_free, NULL); + g_slist_free (prefs->themes); + } + + g_free (prefs->logout_command); + g_free (prefs->keyboard_command); + + G_OBJECT_CLASS (gs_prefs_parent_class)->finalize (object); +} + +GSPrefs * +gs_prefs_new (void) +{ + GObject *prefs; + + prefs = g_object_new (GS_TYPE_PREFS, NULL); + + return GS_PREFS (prefs); +} diff --git a/src/gs-prefs.c.orig b/src/gs-prefs.c.orig new file mode 100644 index 0000000..2aaf2d3 --- /dev/null +++ b/src/gs-prefs.c.orig @@ -0,0 +1,995 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include +#include + +#include "gs-prefs.h" + +static void gs_prefs_class_init (GSPrefsClass *klass); +static void gs_prefs_init (GSPrefs *prefs); +static void gs_prefs_finalize (GObject *object); + +#define MATE_LOCKDOWN_DIR "/desktop/mate/lockdown" +#define KEY_LOCK_DISABLE MATE_LOCKDOWN_DIR "/disable_lock_screen" +#define KEY_USER_SWITCH_DISABLE MATE_LOCKDOWN_DIR "/disable_user_switching" + +#define KEY_DIR "/apps/mate-screensaver" +#define MATE_SESSION_DIR "/desktop/mate/session" +#define KEY_IDLE_ACTIVATION_ENABLED KEY_DIR "/idle_activation_enabled" +#define KEY_LOCK_ENABLED KEY_DIR "/lock_enabled" +#define KEY_MODE KEY_DIR "/mode" +#define KEY_ACTIVATE_DELAY MATE_SESSION_DIR "/idle_delay" +#define KEY_POWER_DELAY KEY_DIR "/power_management_delay" +#define KEY_LOCK_DELAY KEY_DIR "/lock_delay" +#define KEY_CYCLE_DELAY KEY_DIR "/cycle_delay" +#define KEY_THEMES KEY_DIR "/themes" +#define KEY_USER_SWITCH_ENABLED KEY_DIR "/user_switch_enabled" +#define KEY_LOGOUT_ENABLED KEY_DIR "/logout_enabled" +#define KEY_LOGOUT_DELAY KEY_DIR "/logout_delay" +#define KEY_LOGOUT_COMMAND KEY_DIR "/logout_command" +#define KEY_KEYBOARD_ENABLED KEY_DIR "/embedded_keyboard_enabled" +#define KEY_KEYBOARD_COMMAND KEY_DIR "/embedded_keyboard_command" +#define KEY_STATUS_MESSAGE_ENABLED KEY_DIR "/status_message_enabled" + +#define GS_PREFS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_PREFS, GSPrefsPrivate)) + +struct GSPrefsPrivate +{ + MateConfClient *mateconf_client; +}; + +enum +{ + CHANGED, + LAST_SIGNAL +}; + +enum +{ + PROP_0 +}; + +static MateConfEnumStringPair mode_enum_map [] = +{ + { GS_MODE_BLANK_ONLY, "blank-only" }, + { GS_MODE_RANDOM, "random" }, + { GS_MODE_SINGLE, "single" }, + { 0, NULL } +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSPrefs, gs_prefs, G_TYPE_OBJECT) + +static void +gs_prefs_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_prefs_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_prefs_class_init (GSPrefsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_prefs_finalize; + object_class->get_property = gs_prefs_get_property; + object_class->set_property = gs_prefs_set_property; + + + signals [CHANGED] = + g_signal_new ("changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSPrefsClass, changed), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_type_class_add_private (klass, sizeof (GSPrefsPrivate)); + +} + +static void +_gs_prefs_set_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 10; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->timeout = value * 60000; +} + +static void +_gs_prefs_set_power_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 60; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + /* this value is in seconds - others are in minutes */ + prefs->power_timeout = value * 1000; +} + +static void +_gs_prefs_set_lock_timeout (GSPrefs *prefs, + int value) +{ + if (value < 0) + value = 0; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->lock_timeout = value * 60000; +} + +static void +_gs_prefs_set_cycle_timeout (GSPrefs *prefs, + int value) +{ + if (value < 1) + value = 1; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->cycle = value * 60000; +} + +static void +_gs_prefs_set_mode (GSPrefs *prefs, + const char *value) +{ + int mode; + + if (value && mateconf_string_to_enum (mode_enum_map, value, &mode)) + prefs->mode = mode; + else + prefs->mode = GS_MODE_BLANK_ONLY; +} + +static void +_gs_prefs_set_themes (GSPrefs *prefs, + GSList *list) +{ + if (prefs->themes) + { + g_slist_foreach (prefs->themes, (GFunc)g_free, NULL); + g_slist_free (prefs->themes); + } + + /* take ownership of the list */ + prefs->themes = list; +} + +static void +_gs_prefs_set_idle_activation_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->idle_activation_enabled = value; +} + +static void +_gs_prefs_set_lock_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->lock_enabled = value; +} + +static void +_gs_prefs_set_lock_disabled (GSPrefs *prefs, + gboolean value) +{ + prefs->lock_disabled = value; +} + +static void +_gs_prefs_set_user_switch_disabled (GSPrefs *prefs, + gboolean value) +{ + prefs->user_switch_disabled = value; +} + +static void +_gs_prefs_set_keyboard_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->keyboard_enabled = value; +} + +static void +_gs_prefs_set_keyboard_command (GSPrefs *prefs, + const char *value) +{ + g_free (prefs->keyboard_command); + prefs->keyboard_command = NULL; + + if (value) + { + /* FIXME: check command */ + + prefs->keyboard_command = g_strdup (value); + } +} + +static void +_gs_prefs_set_status_message_enabled (GSPrefs *prefs, + gboolean enabled) +{ + prefs->status_message_enabled = enabled; +} + +static void +_gs_prefs_set_logout_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->logout_enabled = value; +} + +static void +_gs_prefs_set_logout_command (GSPrefs *prefs, + const char *value) +{ + g_free (prefs->logout_command); + prefs->logout_command = NULL; + + if (value) + { + /* FIXME: check command */ + + prefs->logout_command = g_strdup (value); + } +} + +static void +_gs_prefs_set_logout_timeout (GSPrefs *prefs, + int value) +{ + if (value < 0) + value = 0; + + /* pick a reasonable large number for the + upper bound */ + if (value > 480) + value = 480; + + prefs->logout_timeout = value * 60000; +} + +static void +_gs_prefs_set_user_switch_enabled (GSPrefs *prefs, + gboolean value) +{ + prefs->user_switch_enabled = value; +} + +static void +key_error_and_free (const char *key, + GError *error) +{ + g_warning ("Error retrieving configuration key '%s': %s", key, error->message); + g_error_free (error); + error = NULL; +} + +static void +gs_prefs_load_from_mateconf (GSPrefs *prefs) +{ + glong value; + gboolean bvalue; + char *string; + GSList *list; + GError *error; + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_IDLE_ACTIVATION_ENABLED, &error); + if (! error) + { + _gs_prefs_set_idle_activation_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_IDLE_ACTIVATION_ENABLED, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOCK_ENABLED, &error); + if (! error) + { + _gs_prefs_set_lock_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOCK_ENABLED, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOCK_DISABLE, &error); + if (! error) + { + _gs_prefs_set_lock_disabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOCK_DISABLE, error); + } + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_USER_SWITCH_DISABLE, &error); + if (! error) + { + _gs_prefs_set_user_switch_disabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_USER_SWITCH_DISABLE, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_ACTIVATE_DELAY, &error); + if (! error) + { + _gs_prefs_set_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_ACTIVATE_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_POWER_DELAY, &error); + if (! error) + { + _gs_prefs_set_power_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_POWER_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_LOCK_DELAY, &error); + if (! error) + { + _gs_prefs_set_lock_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_LOCK_DELAY, error); + } + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_CYCLE_DELAY, &error); + if (! error) + { + _gs_prefs_set_cycle_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_CYCLE_DELAY, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_MODE, &error); + if (! error) + { + _gs_prefs_set_mode (prefs, string); + } + else + { + key_error_and_free (KEY_MODE, error); + } + g_free (string); + + error = NULL; + list = mateconf_client_get_list (prefs->priv->mateconf_client, + KEY_THEMES, + MATECONF_VALUE_STRING, + &error); + if (! error) + { + _gs_prefs_set_themes (prefs, list); + } + else + { + key_error_and_free (KEY_THEMES, error); + } + + /* Embedded keyboard options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_KEYBOARD_ENABLED, &error); + if (! error) + { + _gs_prefs_set_keyboard_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_KEYBOARD_ENABLED, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_KEYBOARD_COMMAND, &error); + if (! error) + { + _gs_prefs_set_keyboard_command (prefs, string); + } + else + { + key_error_and_free (KEY_KEYBOARD_COMMAND, error); + } + g_free (string); + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_STATUS_MESSAGE_ENABLED, &error); + if (! error) + { + _gs_prefs_set_status_message_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_STATUS_MESSAGE_ENABLED, error); + } + + /* Logout options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_LOGOUT_ENABLED, &error); + if (! error) + { + _gs_prefs_set_logout_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_LOGOUT_ENABLED, error); + } + + error = NULL; + string = mateconf_client_get_string (prefs->priv->mateconf_client, KEY_LOGOUT_COMMAND, &error); + if (! error) + { + _gs_prefs_set_logout_command (prefs, string); + } + else + { + key_error_and_free (KEY_LOGOUT_COMMAND, error); + } + g_free (string); + + error = NULL; + value = mateconf_client_get_int (prefs->priv->mateconf_client, KEY_LOGOUT_DELAY, &error); + if (! error) + { + _gs_prefs_set_logout_timeout (prefs, value); + } + else + { + key_error_and_free (KEY_LOGOUT_DELAY, error); + } + + /* User switching options */ + + error = NULL; + bvalue = mateconf_client_get_bool (prefs->priv->mateconf_client, KEY_USER_SWITCH_ENABLED, &error); + if (! error) + { + _gs_prefs_set_user_switch_enabled (prefs, bvalue); + } + else + { + key_error_and_free (KEY_USER_SWITCH_ENABLED, error); + } +} + +static void +invalid_type_warning (const char *type) +{ + g_warning ("Error retrieving configuration key '%s': Invalid type", + type); +} + +static void +key_changed_cb (MateConfClient *client, + guint cnxn_id, + MateConfEntry *entry, + GSPrefs *prefs) +{ + gboolean changed = FALSE; + 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_MODE) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *str; + + str = mateconf_value_get_string (value); + _gs_prefs_set_mode (prefs, str); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_THEMES) == 0) + { + GSList *list = NULL; + + if (value == NULL + || value->type != MATECONF_VALUE_LIST) + { + return; + } + + list = mateconf_value_get_list (value); + + if (list + && mateconf_value_get_list_type (value) == MATECONF_VALUE_STRING) + { + GSList *l; + GSList *new_list; + + changed = TRUE; + + new_list = NULL; + for (l = list; l; l = l->next) + { + char *s; + + s = mateconf_value_to_string (l->data); + + new_list = g_slist_prepend (new_list, g_strdup (s)); + + g_free (s); + } + + new_list = g_slist_reverse (new_list); + + _gs_prefs_set_themes (prefs, new_list); + + } + + } + else if (strcmp (key, KEY_ACTIVATE_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_POWER_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_power_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOCK_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_lock_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_IDLE_ACTIVATION_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_idle_activation_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOCK_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_lock_enabled (prefs, enabled); + + changed = TRUE; + } + 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); + _gs_prefs_set_lock_disabled (prefs, disabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_USER_SWITCH_DISABLE) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean disabled; + + disabled = mateconf_value_get_bool (value); + _gs_prefs_set_user_switch_disabled (prefs, disabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_CYCLE_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_cycle_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_KEYBOARD_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_keyboard_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_KEYBOARD_COMMAND) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *command; + + command = mateconf_value_get_string (value); + _gs_prefs_set_keyboard_command (prefs, command); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_STATUS_MESSAGE_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_status_message_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_logout_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_DELAY) == 0) + { + + if (value->type == MATECONF_VALUE_INT) + { + int delay; + + delay = mateconf_value_get_int (value); + _gs_prefs_set_logout_timeout (prefs, delay); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_LOGOUT_COMMAND) == 0) + { + + if (value->type == MATECONF_VALUE_STRING) + { + const char *command; + + command = mateconf_value_get_string (value); + _gs_prefs_set_logout_command (prefs, command); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else if (strcmp (key, KEY_USER_SWITCH_ENABLED) == 0) + { + + if (value->type == MATECONF_VALUE_BOOL) + { + gboolean enabled; + + enabled = mateconf_value_get_bool (value); + _gs_prefs_set_user_switch_enabled (prefs, enabled); + + changed = TRUE; + } + else + { + invalid_type_warning (key); + } + + } + else + { + g_warning ("Config key not handled: %s", key); + } + + if (changed && prefs) + { + g_signal_emit (prefs, signals [CHANGED], 0); + } +} + +static void +gs_prefs_init (GSPrefs *prefs) +{ + prefs->priv = GS_PREFS_GET_PRIVATE (prefs); + + prefs->priv->mateconf_client = mateconf_client_get_default (); + + prefs->idle_activation_enabled = TRUE; + prefs->lock_enabled = TRUE; + prefs->lock_disabled = FALSE; + prefs->logout_enabled = FALSE; + prefs->user_switch_enabled = FALSE; + + prefs->timeout = 600000; + prefs->power_timeout = 60000; + prefs->lock_timeout = 0; + prefs->logout_timeout = 14400000; + prefs->cycle = 600000; + + prefs->mode = GS_MODE_SINGLE; + + /* MateConf setup */ + mateconf_client_add_dir (prefs->priv->mateconf_client, + KEY_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + mateconf_client_add_dir (prefs->priv->mateconf_client, + MATE_LOCKDOWN_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + mateconf_client_add_dir (prefs->priv->mateconf_client, + MATE_SESSION_DIR, + MATECONF_CLIENT_PRELOAD_NONE, NULL); + + + mateconf_client_notify_add (prefs->priv->mateconf_client, + KEY_DIR, + (MateConfClientNotifyFunc)key_changed_cb, + prefs, + NULL, NULL); + mateconf_client_notify_add (prefs->priv->mateconf_client, + MATE_LOCKDOWN_DIR, + (MateConfClientNotifyFunc)key_changed_cb, + prefs, + NULL, NULL); + + gs_prefs_load_from_mateconf (prefs); +} + +static void +gs_prefs_finalize (GObject *object) +{ + GSPrefs *prefs; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_PREFS (object)); + + prefs = GS_PREFS (object); + + g_return_if_fail (prefs->priv != NULL); + + if (prefs->priv->mateconf_client) + { + g_object_unref (prefs->priv->mateconf_client); + prefs->priv->mateconf_client = NULL; + } + + if (prefs->themes) + { + g_slist_foreach (prefs->themes, (GFunc)g_free, NULL); + g_slist_free (prefs->themes); + } + + g_free (prefs->logout_command); + g_free (prefs->keyboard_command); + + G_OBJECT_CLASS (gs_prefs_parent_class)->finalize (object); +} + +GSPrefs * +gs_prefs_new (void) +{ + GObject *prefs; + + prefs = g_object_new (GS_TYPE_PREFS, NULL); + + return GS_PREFS (prefs); +} diff --git a/src/gs-prefs.h b/src/gs-prefs.h new file mode 100644 index 0000000..7a354dd --- /dev/null +++ b/src/gs-prefs.h @@ -0,0 +1,85 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_PREFS_H +#define __GS_PREFS_H + +G_BEGIN_DECLS + +#define GS_TYPE_PREFS (gs_prefs_get_type ()) +#define GS_PREFS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_PREFS, GSPrefs)) +#define GS_PREFS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_PREFS, GSPrefsClass)) +#define GS_IS_PREFS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_PREFS)) +#define GS_IS_PREFS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_PREFS)) +#define GS_PREFS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_PREFS, GSPrefsClass)) + +typedef enum +{ + GS_MODE_BLANK_ONLY, + GS_MODE_RANDOM, + GS_MODE_SINGLE +} GSSaverMode; + +typedef struct GSPrefsPrivate GSPrefsPrivate; + +typedef struct +{ + GObject parent; + + GSPrefsPrivate *priv; + + guint idle_activation_enabled : 1; /* whether to activate when idle */ + guint lock_enabled : 1; /* whether to lock when active */ + guint logout_enabled : 1; /* Whether to offer the logout option */ + guint lock_disabled : 1; /* Whether locking the system is disabled */ + guint user_switch_disabled : 1; /* Whether user switching is disabled */ + guint user_switch_enabled : 1; /* Whether to offer the user switch option */ + guint keyboard_enabled : 1; /* Whether to try to embed a keyboard */ + guint status_message_enabled : 1; /* show the status message in the lock */ + + guint power_timeout; /* how much idle time before power management */ + guint timeout; /* how much idle time before activation */ + guint lock_timeout; /* how long after activation locking starts */ + guint logout_timeout; /* how long until the logout option appears */ + guint cycle; /* how long each theme should run */ + + char *logout_command; /* command to use to logout */ + char *keyboard_command; /* command to use to embed a keyboard */ + + GSList *themes; /* the screensaver themes to run */ + GSSaverMode mode; /* theme selection mode */ +} GSPrefs; + +typedef struct +{ + GObjectClass parent_class; + + void (* changed) (GSPrefs *prefs); +} GSPrefsClass; + +GType gs_prefs_get_type (void); +GSPrefs * gs_prefs_new (void); +void gs_prefs_load (GSPrefs *prefs); + +G_END_DECLS + +#endif /* __GS_PREFS_H */ diff --git a/src/gs-prefs.h.orig b/src/gs-prefs.h.orig new file mode 100644 index 0000000..3545471 --- /dev/null +++ b/src/gs-prefs.h.orig @@ -0,0 +1,85 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_PREFS_H +#define __GS_PREFS_H + +G_BEGIN_DECLS + +#define GS_TYPE_PREFS (gs_prefs_get_type ()) +#define GS_PREFS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_PREFS, GSPrefs)) +#define GS_PREFS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_PREFS, GSPrefsClass)) +#define GS_IS_PREFS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_PREFS)) +#define GS_IS_PREFS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_PREFS)) +#define GS_PREFS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_PREFS, GSPrefsClass)) + +typedef enum +{ + GS_MODE_BLANK_ONLY, + GS_MODE_RANDOM, + GS_MODE_SINGLE +} GSSaverMode; + +typedef struct GSPrefsPrivate GSPrefsPrivate; + +typedef struct +{ + GObject parent; + + GSPrefsPrivate *priv; + + guint idle_activation_enabled : 1; /* whether to activate when idle */ + guint lock_enabled : 1; /* whether to lock when active */ + guint logout_enabled : 1; /* Whether to offer the logout option */ + guint lock_disabled : 1; /* Whether locking the system is disabled */ + guint user_switch_disabled : 1; /* Whether user switching is disabled */ + guint user_switch_enabled : 1; /* Whether to offer the user switch option */ + guint keyboard_enabled : 1; /* Whether to try to embed a keyboard */ + guint status_message_enabled : 1; /* show the status message in the lock */ + + guint power_timeout; /* how much idle time before power management */ + guint timeout; /* how much idle time before activation */ + guint lock_timeout; /* how long after activation locking starts */ + guint logout_timeout; /* how long until the logout option appears */ + guint cycle; /* how long each theme should run */ + + char *logout_command; /* command to use to logout */ + char *keyboard_command; /* command to use to embed a keyboard */ + + GSList *themes; /* the screensaver themes to run */ + GSSaverMode mode; /* theme selection mode */ +} GSPrefs; + +typedef struct +{ + GObjectClass parent_class; + + void (* changed) (GSPrefs *prefs); +} GSPrefsClass; + +GType gs_prefs_get_type (void); +GSPrefs * gs_prefs_new (void); +void gs_prefs_load (GSPrefs *prefs); + +G_END_DECLS + +#endif /* __GS_PREFS_H */ diff --git a/src/gs-theme-manager.c b/src/gs-theme-manager.c new file mode 100644 index 0000000..32b086f --- /dev/null +++ b/src/gs-theme-manager.c @@ -0,0 +1,453 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include + +#include +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#include +#include + +#include "gs-theme-manager.h" +#include "gs-debug.h" + +static void gs_theme_manager_class_init (GSThemeManagerClass *klass); +static void gs_theme_manager_init (GSThemeManager *theme_manager); +static void gs_theme_manager_finalize (GObject *object); + +#define GS_THEME_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_THEME_MANAGER, GSThemeManagerPrivate)) + +struct _GSThemeInfo +{ + char *name; + char *exec; + char *file_id; + guint refcount; +}; + +struct GSThemeManagerPrivate +{ + MateMenuTree *menu_tree; +}; + +G_DEFINE_TYPE (GSThemeManager, gs_theme_manager, G_TYPE_OBJECT) + +static gpointer theme_manager_object = NULL; + +static const char *known_engine_locations [] = +{ + SAVERDIR, +#ifdef XSCREENSAVER_HACK_DIR + XSCREENSAVER_HACK_DIR, +#endif + LIBEXECDIR "/xscreensaver", + "/usr/libexec/xscreensaver", + "/usr/lib/xscreensaver", + NULL +}; + +/* Returns the full path to the queried command */ +static char * +find_command (const char *command) +{ + int i; + + if (g_path_is_absolute (command)) + { + char *dirname; + + dirname = g_path_get_dirname (command); + for (i = 0; known_engine_locations [i]; i++) + { + if (strcmp (dirname, known_engine_locations [i]) == 0) + { + if (g_file_test (command, G_FILE_TEST_IS_EXECUTABLE) + && ! g_file_test (command, G_FILE_TEST_IS_DIR)) + { + g_free (dirname); + return g_strdup (command); + } + } + } + g_free (dirname); + } + else + { + for (i = 0; known_engine_locations [i]; i++) + { + char *path; + + path = g_build_filename (known_engine_locations [i], command, NULL); + + if (g_file_test (path, G_FILE_TEST_IS_EXECUTABLE) + && ! g_file_test (path, G_FILE_TEST_IS_DIR)) + { + return path; + } + + g_free (path); + } + } + + return NULL; +} + +static gboolean +check_command (const char *command) +{ + char *path; + char **argv; + + g_return_val_if_fail (command != NULL, FALSE); + + g_shell_parse_argv (command, NULL, &argv, NULL); + path = find_command (argv [0]); + g_strfreev (argv); + + if (path != NULL) + { + g_free (path); + return TRUE; + } + + return FALSE; +} + +static void +add_known_engine_locations_to_path (void) +{ + static gboolean already_added; + int i; + GString *str; + + /* We only want to add the items to the path once */ + if (already_added) + { + return; + } + + already_added = TRUE; + + /* TODO: set a default PATH ? */ + + str = g_string_new (g_getenv ("PATH")); + for (i = 0; known_engine_locations [i]; i++) + { + /* TODO: check that permissions are safe */ + if (g_file_test (known_engine_locations [i], G_FILE_TEST_IS_DIR)) + { + g_string_append_printf (str, ":%s", known_engine_locations [i]); + } + } + + g_setenv ("PATH", str->str, TRUE); + g_string_free (str, TRUE); +} + +GSThemeInfo * +gs_theme_info_ref (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + g_return_val_if_fail (info->refcount > 0, NULL); + + info->refcount++; + + return info; +} + +void +gs_theme_info_unref (GSThemeInfo *info) +{ + g_return_if_fail (info != NULL); + g_return_if_fail (info->refcount > 0); + + if (--info->refcount == 0) + { + g_free (info->name); + g_free (info->exec); + g_free (info->file_id); + + g_free (info); + } +} + +const char * +gs_theme_info_get_id (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + + return info->file_id; +} + +const char * +gs_theme_info_get_name (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + + return info->name; +} + +const char * +gs_theme_info_get_exec (GSThemeInfo *info) +{ + const char *exec; + + g_return_val_if_fail (info != NULL, NULL); + + if (check_command (info->exec)) + { + exec = info->exec; + } + else + { + exec = NULL; + } + + return exec; +} + +static GSThemeInfo * +gs_theme_info_new_from_matemenu_tree_entry (MateMenuTreeEntry *entry) +{ + GSThemeInfo *info; + const char *str; + char *pos; + + info = g_new0 (GSThemeInfo, 1); + + info->refcount = 1; + info->name = g_strdup (matemenu_tree_entry_get_name (entry)); + info->exec = g_strdup (matemenu_tree_entry_get_exec (entry)); + + /* remove the .desktop suffix */ + str = matemenu_tree_entry_get_desktop_file_id (entry); + pos = g_strrstr (str, ".desktop"); + if (pos) + { + info->file_id = g_strndup (str, pos - str); + } + else + { + info->file_id = g_strdup (str); + } + + return info; +} + +static GSThemeInfo * +find_info_for_id (MateMenuTree *tree, + const char *id) +{ + GSThemeInfo *info; + MateMenuTreeDirectory *root; + GSList *items; + GSList *l; + + root = matemenu_tree_get_root_directory (tree); + if (root == NULL) + { + return NULL; + } + + items = matemenu_tree_directory_get_contents (root); + + info = NULL; + + for (l = items; l; l = l->next) + { + if (info == NULL + && matemenu_tree_item_get_type (l->data) == MATEMENU_TREE_ITEM_ENTRY) + { + MateMenuTreeEntry *entry = l->data; + const char *file_id; + + file_id = matemenu_tree_entry_get_desktop_file_id (entry); + if (file_id && id && strcmp (file_id, id) == 0) + { + info = gs_theme_info_new_from_matemenu_tree_entry (entry); + } + } + + matemenu_tree_item_unref (l->data); + } + + g_slist_free (items); + matemenu_tree_item_unref (root); + + return info; +} + +GSThemeInfo * +gs_theme_manager_lookup_theme_info (GSThemeManager *theme_manager, + const char *name) +{ + GSThemeInfo *info; + char *id; + + g_return_val_if_fail (GS_IS_THEME_MANAGER (theme_manager), NULL); + g_return_val_if_fail (name != NULL, NULL); + + id = g_strdup_printf ("%s.desktop", name); + info = find_info_for_id (theme_manager->priv->menu_tree, id); + g_free (id); + + return info; +} + +static void +theme_prepend_entry (GSList **parent_list, + MateMenuTreeEntry *entry, + const char *filename) +{ + GSThemeInfo *info; + + info = gs_theme_info_new_from_matemenu_tree_entry (entry); + + *parent_list = g_slist_prepend (*parent_list, info); +} + +static void +make_theme_list (GSList **parent_list, + MateMenuTreeDirectory *directory, + const char *filename) +{ + GSList *items; + GSList *l; + + items = matemenu_tree_directory_get_contents (directory); + + for (l = items; l; l = l->next) + { + switch (matemenu_tree_item_get_type (l->data)) + { + + case MATEMENU_TREE_ITEM_ENTRY: + theme_prepend_entry (parent_list, l->data, filename); + break; + + case MATEMENU_TREE_ITEM_ALIAS: + case MATEMENU_TREE_ITEM_DIRECTORY: + default: + break; + } + + matemenu_tree_item_unref (l->data); + } + + g_slist_free (items); + + *parent_list = g_slist_reverse (*parent_list); +} + +GSList * +gs_theme_manager_get_info_list (GSThemeManager *theme_manager) +{ + GSList *l = NULL; + MateMenuTreeDirectory *root; + + g_return_val_if_fail (GS_IS_THEME_MANAGER (theme_manager), NULL); + + root = matemenu_tree_get_root_directory (theme_manager->priv->menu_tree); + + if (root != NULL) + { + make_theme_list (&l, root, "mate-screensavers.menu"); + matemenu_tree_item_unref (root); + } + + return l; +} + +static void +gs_theme_manager_class_init (GSThemeManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_theme_manager_finalize; + + g_type_class_add_private (klass, sizeof (GSThemeManagerPrivate)); +} + +static MateMenuTree * +get_themes_tree (void) +{ + MateMenuTree *themes_tree = NULL; + + /* we only need to add the locations to the path once + and since this is only run once we'll do it here */ + add_known_engine_locations_to_path (); + + themes_tree = matemenu_tree_lookup ("mate-screensavers.menu", MATEMENU_TREE_FLAGS_NONE); + + return themes_tree; +} + +static void +gs_theme_manager_init (GSThemeManager *theme_manager) +{ + theme_manager->priv = GS_THEME_MANAGER_GET_PRIVATE (theme_manager); + + theme_manager->priv->menu_tree = get_themes_tree (); +} + +static void +gs_theme_manager_finalize (GObject *object) +{ + GSThemeManager *theme_manager; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_THEME_MANAGER (object)); + + theme_manager = GS_THEME_MANAGER (object); + + g_return_if_fail (theme_manager->priv != NULL); + + if (theme_manager->priv->menu_tree != NULL) + { + matemenu_tree_unref (theme_manager->priv->menu_tree); + } + + G_OBJECT_CLASS (gs_theme_manager_parent_class)->finalize (object); +} + +GSThemeManager * +gs_theme_manager_new (void) +{ + if (theme_manager_object) + { + g_object_ref (theme_manager_object); + } + else + { + theme_manager_object = g_object_new (GS_TYPE_THEME_MANAGER, NULL); + g_object_add_weak_pointer (theme_manager_object, + (gpointer *) &theme_manager_object); + } + + return GS_THEME_MANAGER (theme_manager_object); +} diff --git a/src/gs-theme-manager.c.orig b/src/gs-theme-manager.c.orig new file mode 100644 index 0000000..48b3c41 --- /dev/null +++ b/src/gs-theme-manager.c.orig @@ -0,0 +1,453 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include + +#include +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#include +#include + +#include "gs-theme-manager.h" +#include "gs-debug.h" + +static void gs_theme_manager_class_init (GSThemeManagerClass *klass); +static void gs_theme_manager_init (GSThemeManager *theme_manager); +static void gs_theme_manager_finalize (GObject *object); + +#define GS_THEME_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_THEME_MANAGER, GSThemeManagerPrivate)) + +struct _GSThemeInfo +{ + char *name; + char *exec; + char *file_id; + guint refcount; +}; + +struct GSThemeManagerPrivate +{ + MateMenuTree *menu_tree; +}; + +G_DEFINE_TYPE (GSThemeManager, gs_theme_manager, G_TYPE_OBJECT) + +static gpointer theme_manager_object = NULL; + +static const char *known_engine_locations [] = +{ + SAVERDIR, +#ifdef XSCREENSAVER_HACK_DIR + XSCREENSAVER_HACK_DIR, +#endif + LIBEXECDIR "/xscreensaver", + "/usr/libexec/xscreensaver", + "/usr/lib/xscreensaver", + NULL +}; + +/* Returns the full path to the queried command */ +static char * +find_command (const char *command) +{ + int i; + + if (g_path_is_absolute (command)) + { + char *dirname; + + dirname = g_path_get_dirname (command); + for (i = 0; known_engine_locations [i]; i++) + { + if (strcmp (dirname, known_engine_locations [i]) == 0) + { + if (g_file_test (command, G_FILE_TEST_IS_EXECUTABLE) + && ! g_file_test (command, G_FILE_TEST_IS_DIR)) + { + g_free (dirname); + return g_strdup (command); + } + } + } + g_free (dirname); + } + else + { + for (i = 0; known_engine_locations [i]; i++) + { + char *path; + + path = g_build_filename (known_engine_locations [i], command, NULL); + + if (g_file_test (path, G_FILE_TEST_IS_EXECUTABLE) + && ! g_file_test (path, G_FILE_TEST_IS_DIR)) + { + return path; + } + + g_free (path); + } + } + + return NULL; +} + +static gboolean +check_command (const char *command) +{ + char *path; + char **argv; + + g_return_val_if_fail (command != NULL, FALSE); + + g_shell_parse_argv (command, NULL, &argv, NULL); + path = find_command (argv [0]); + g_strfreev (argv); + + if (path != NULL) + { + g_free (path); + return TRUE; + } + + return FALSE; +} + +static void +add_known_engine_locations_to_path (void) +{ + static gboolean already_added; + int i; + GString *str; + + /* We only want to add the items to the path once */ + if (already_added) + { + return; + } + + already_added = TRUE; + + /* TODO: set a default PATH ? */ + + str = g_string_new (g_getenv ("PATH")); + for (i = 0; known_engine_locations [i]; i++) + { + /* TODO: check that permissions are safe */ + if (g_file_test (known_engine_locations [i], G_FILE_TEST_IS_DIR)) + { + g_string_append_printf (str, ":%s", known_engine_locations [i]); + } + } + + g_setenv ("PATH", str->str, TRUE); + g_string_free (str, TRUE); +} + +GSThemeInfo * +gs_theme_info_ref (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + g_return_val_if_fail (info->refcount > 0, NULL); + + info->refcount++; + + return info; +} + +void +gs_theme_info_unref (GSThemeInfo *info) +{ + g_return_if_fail (info != NULL); + g_return_if_fail (info->refcount > 0); + + if (--info->refcount == 0) + { + g_free (info->name); + g_free (info->exec); + g_free (info->file_id); + + g_free (info); + } +} + +const char * +gs_theme_info_get_id (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + + return info->file_id; +} + +const char * +gs_theme_info_get_name (GSThemeInfo *info) +{ + g_return_val_if_fail (info != NULL, NULL); + + return info->name; +} + +const char * +gs_theme_info_get_exec (GSThemeInfo *info) +{ + const char *exec; + + g_return_val_if_fail (info != NULL, NULL); + + if (check_command (info->exec)) + { + exec = info->exec; + } + else + { + exec = NULL; + } + + return exec; +} + +static GSThemeInfo * +gs_theme_info_new_from_matemenu_tree_entry (MateMenuTreeEntry *entry) +{ + GSThemeInfo *info; + const char *str; + char *pos; + + info = g_new0 (GSThemeInfo, 1); + + info->refcount = 1; + info->name = g_strdup (matemenu_tree_entry_get_name (entry)); + info->exec = g_strdup (matemenu_tree_entry_get_exec (entry)); + + /* remove the .desktop suffix */ + str = matemenu_tree_entry_get_desktop_file_id (entry); + pos = g_strrstr (str, ".desktop"); + if (pos) + { + info->file_id = g_strndup (str, pos - str); + } + else + { + info->file_id = g_strdup (str); + } + + return info; +} + +static GSThemeInfo * +find_info_for_id (MateMenuTree *tree, + const char *id) +{ + GSThemeInfo *info; + MateMenuTreeDirectory *root; + GSList *items; + GSList *l; + + root = matemenu_tree_get_root_directory (tree); + if (root == NULL) + { + return NULL; + } + + items = matemenu_tree_directory_get_contents (root); + + info = NULL; + + for (l = items; l; l = l->next) + { + if (info == NULL + && matemenu_tree_item_get_type (l->data) == MATEMENU_TREE_ITEM_ENTRY) + { + MateMenuTreeEntry *entry = l->data; + const char *file_id; + + file_id = matemenu_tree_entry_get_desktop_file_id (entry); + if (file_id && id && strcmp (file_id, id) == 0) + { + info = gs_theme_info_new_from_matemenu_tree_entry (entry); + } + } + + matemenu_tree_item_unref (l->data); + } + + g_slist_free (items); + matemenu_tree_item_unref (root); + + return info; +} + +GSThemeInfo * +gs_theme_manager_lookup_theme_info (GSThemeManager *theme_manager, + const char *name) +{ + GSThemeInfo *info; + char *id; + + g_return_val_if_fail (GS_IS_THEME_MANAGER (theme_manager), NULL); + g_return_val_if_fail (name != NULL, NULL); + + id = g_strdup_printf ("%s.desktop", name); + info = find_info_for_id (theme_manager->priv->menu_tree, id); + g_free (id); + + return info; +} + +static void +theme_prepend_entry (GSList **parent_list, + MateMenuTreeEntry *entry, + const char *filename) +{ + GSThemeInfo *info; + + info = gs_theme_info_new_from_matemenu_tree_entry (entry); + + *parent_list = g_slist_prepend (*parent_list, info); +} + +static void +make_theme_list (GSList **parent_list, + MateMenuTreeDirectory *directory, + const char *filename) +{ + GSList *items; + GSList *l; + + items = matemenu_tree_directory_get_contents (directory); + + for (l = items; l; l = l->next) + { + switch (matemenu_tree_item_get_type (l->data)) + { + + case MATEMENU_TREE_ITEM_ENTRY: + theme_prepend_entry (parent_list, l->data, filename); + break; + + case MATEMENU_TREE_ITEM_ALIAS: + case MATEMENU_TREE_ITEM_DIRECTORY: + default: + break; + } + + matemenu_tree_item_unref (l->data); + } + + g_slist_free (items); + + *parent_list = g_slist_reverse (*parent_list); +} + +GSList * +gs_theme_manager_get_info_list (GSThemeManager *theme_manager) +{ + GSList *l = NULL; + MateMenuTreeDirectory *root; + + g_return_val_if_fail (GS_IS_THEME_MANAGER (theme_manager), NULL); + + root = matemenu_tree_get_root_directory (theme_manager->priv->menu_tree); + + if (root != NULL) + { + make_theme_list (&l, root, "mate-screensavers.menu"); + matemenu_tree_item_unref (root); + } + + return l; +} + +static void +gs_theme_manager_class_init (GSThemeManagerClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_theme_manager_finalize; + + g_type_class_add_private (klass, sizeof (GSThemeManagerPrivate)); +} + +static MateMenuTree * +get_themes_tree (void) +{ + MateMenuTree *themes_tree = NULL; + + /* we only need to add the locations to the path once + and since this is only run once we'll do it here */ + add_known_engine_locations_to_path (); + + themes_tree = matemenu_tree_lookup ("mate-screensavers.menu", MATEMENU_TREE_FLAGS_NONE); + + return themes_tree; +} + +static void +gs_theme_manager_init (GSThemeManager *theme_manager) +{ + theme_manager->priv = GS_THEME_MANAGER_GET_PRIVATE (theme_manager); + + theme_manager->priv->menu_tree = get_themes_tree (); +} + +static void +gs_theme_manager_finalize (GObject *object) +{ + GSThemeManager *theme_manager; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_THEME_MANAGER (object)); + + theme_manager = GS_THEME_MANAGER (object); + + g_return_if_fail (theme_manager->priv != NULL); + + if (theme_manager->priv->menu_tree != NULL) + { + matemenu_tree_unref (theme_manager->priv->menu_tree); + } + + G_OBJECT_CLASS (gs_theme_manager_parent_class)->finalize (object); +} + +GSThemeManager * +gs_theme_manager_new (void) +{ + if (theme_manager_object) + { + g_object_ref (theme_manager_object); + } + else + { + theme_manager_object = g_object_new (GS_TYPE_THEME_MANAGER, NULL); + g_object_add_weak_pointer (theme_manager_object, + (gpointer *) &theme_manager_object); + } + + return GS_THEME_MANAGER (theme_manager_object); +} diff --git a/src/gs-theme-manager.h b/src/gs-theme-manager.h new file mode 100644 index 0000000..5b79309 --- /dev/null +++ b/src/gs-theme-manager.h @@ -0,0 +1,65 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_THEME_MANAGER_H +#define __GS_THEME_MANAGER_H + +G_BEGIN_DECLS + +#define GS_TYPE_THEME_MANAGER (gs_theme_manager_get_type ()) +#define GS_THEME_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_THEME_MANAGER, GSThemeManager)) +#define GS_THEME_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_THEME_MANAGER, GSThemeManagerClass)) +#define GS_IS_THEME_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_THEME_MANAGER)) +#define GS_IS_THEME_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_THEME_MANAGER)) +#define GS_THEME_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_THEME_MANAGER, GSThemeManagerClass)) + +typedef struct GSThemeManagerPrivate GSThemeManagerPrivate; + +typedef struct +{ + GObject parent; + GSThemeManagerPrivate *priv; +} GSThemeManager; + +typedef struct +{ + GObjectClass parent_class; +} GSThemeManagerClass; + +typedef struct _GSThemeInfo GSThemeInfo; + +GType gs_theme_manager_get_type (void); + +GSThemeManager *gs_theme_manager_new (void); + +GSList *gs_theme_manager_get_info_list (GSThemeManager *manager); +GSThemeInfo *gs_theme_manager_lookup_theme_info (GSThemeManager *manager, + const char *theme); +GSThemeInfo *gs_theme_info_ref (GSThemeInfo *info); +void gs_theme_info_unref (GSThemeInfo *info); +const char *gs_theme_info_get_id (GSThemeInfo *info); +const char *gs_theme_info_get_name (GSThemeInfo *info); +const char *gs_theme_info_get_exec (GSThemeInfo *info); + +G_END_DECLS + +#endif /* __GS_THEME_MANAGER_H */ diff --git a/src/gs-theme-manager.h.orig b/src/gs-theme-manager.h.orig new file mode 100644 index 0000000..8472961 --- /dev/null +++ b/src/gs-theme-manager.h.orig @@ -0,0 +1,65 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_THEME_MANAGER_H +#define __GS_THEME_MANAGER_H + +G_BEGIN_DECLS + +#define GS_TYPE_THEME_MANAGER (gs_theme_manager_get_type ()) +#define GS_THEME_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_THEME_MANAGER, GSThemeManager)) +#define GS_THEME_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_THEME_MANAGER, GSThemeManagerClass)) +#define GS_IS_THEME_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_THEME_MANAGER)) +#define GS_IS_THEME_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_THEME_MANAGER)) +#define GS_THEME_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_THEME_MANAGER, GSThemeManagerClass)) + +typedef struct GSThemeManagerPrivate GSThemeManagerPrivate; + +typedef struct +{ + GObject parent; + GSThemeManagerPrivate *priv; +} GSThemeManager; + +typedef struct +{ + GObjectClass parent_class; +} GSThemeManagerClass; + +typedef struct _GSThemeInfo GSThemeInfo; + +GType gs_theme_manager_get_type (void); + +GSThemeManager *gs_theme_manager_new (void); + +GSList *gs_theme_manager_get_info_list (GSThemeManager *manager); +GSThemeInfo *gs_theme_manager_lookup_theme_info (GSThemeManager *manager, + const char *theme); +GSThemeInfo *gs_theme_info_ref (GSThemeInfo *info); +void gs_theme_info_unref (GSThemeInfo *info); +const char *gs_theme_info_get_id (GSThemeInfo *info); +const char *gs_theme_info_get_name (GSThemeInfo *info); +const char *gs_theme_info_get_exec (GSThemeInfo *info); + +G_END_DECLS + +#endif /* __GS_THEME_MANAGER_H */ diff --git a/src/gs-visual-gl.c b/src/gs-visual-gl.c new file mode 100644 index 0000000..7a71c79 --- /dev/null +++ b/src/gs-visual-gl.c @@ -0,0 +1,116 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * Copyright (C) 1999, 2000, 2003 Jamie Zawinski + * + * 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. + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include +#include + +#ifdef HAVE_LIBGL +#include +#include +#endif /* HAVE_GL */ + +#include "gs-visual-gl.h" +#include "gs-debug.h" + +GdkVisual * +gs_visual_gl_get_best_for_screen (GdkScreen *screen) +{ + GdkVisual *visual; +#ifdef HAVE_LIBGL + GdkDisplay *display; + int screen_num; + int i; + +# define R GLX_RED_SIZE +# define G GLX_GREEN_SIZE +# define B GLX_BLUE_SIZE +# define D GLX_DEPTH_SIZE +# define I GLX_BUFFER_SIZE +# define DB GLX_DOUBLEBUFFER +# define ST GLX_STENCIL_SIZE + + static int attrs [][20] = + { + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, DB, ST,1, 0 }, /* rgb double, stencil */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, DB, ST,1, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, DB, ST,1, 0 }, + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, DB, 0 }, /* rgb double */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, DB, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, DB, 0 }, + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, 0 }, /* rgb single */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, 0 }, + { I, 8, D, 8, DB, 0 }, /* cmap double */ + { I, 4, D, 4, DB, 0 }, + { I, 8, D, 8, 0 }, /* cmap single */ + { I, 4, D, 4, 0 }, + { GLX_RGBA, R, 1, G, 1, B, 1, D, 1, 0 } /* monochrome */ + }; + + g_return_val_if_fail (screen != NULL, NULL); + + display = gdk_screen_get_display (screen); + screen_num = gdk_screen_get_number (screen); + + gdk_error_trap_push (); + + visual = NULL; + for (i = 0; i < G_N_ELEMENTS (attrs); i++) + { + XVisualInfo *vi; + + vi = glXChooseVisual (GDK_DISPLAY_XDISPLAY (display), screen_num, attrs [i]); + + if (vi != NULL) + { + VisualID vid; + + vid = XVisualIDFromVisual (vi->visual); + + visual = gdkx_visual_get (vid); + + XFree (vi); + + if (visual != NULL) + { + break; + } + } + } + + gdk_display_sync (display); + gdk_error_trap_pop (); + +#else + visual = NULL; + +#endif /* HAVE_LIBGL */ + + return visual; +} diff --git a/src/gs-visual-gl.c.orig b/src/gs-visual-gl.c.orig new file mode 100644 index 0000000..e253b28 --- /dev/null +++ b/src/gs-visual-gl.c.orig @@ -0,0 +1,116 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * Copyright (C) 1999, 2000, 2003 Jamie Zawinski + * + * 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. + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include +#include + +#ifdef HAVE_LIBGL +#include +#include +#endif /* HAVE_GL */ + +#include "gs-visual-gl.h" +#include "gs-debug.h" + +GdkVisual * +gs_visual_gl_get_best_for_screen (GdkScreen *screen) +{ + GdkVisual *visual; +#ifdef HAVE_LIBGL + GdkDisplay *display; + int screen_num; + int i; + +# define R GLX_RED_SIZE +# define G GLX_GREEN_SIZE +# define B GLX_BLUE_SIZE +# define D GLX_DEPTH_SIZE +# define I GLX_BUFFER_SIZE +# define DB GLX_DOUBLEBUFFER +# define ST GLX_STENCIL_SIZE + + static int attrs [][20] = + { + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, DB, ST,1, 0 }, /* rgb double, stencil */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, DB, ST,1, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, DB, ST,1, 0 }, + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, DB, 0 }, /* rgb double */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, DB, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, DB, 0 }, + { GLX_RGBA, R, 8, G, 8, B, 8, D, 8, 0 }, /* rgb single */ + { GLX_RGBA, R, 4, G, 4, B, 4, D, 4, 0 }, + { GLX_RGBA, R, 2, G, 2, B, 2, D, 2, 0 }, + { I, 8, D, 8, DB, 0 }, /* cmap double */ + { I, 4, D, 4, DB, 0 }, + { I, 8, D, 8, 0 }, /* cmap single */ + { I, 4, D, 4, 0 }, + { GLX_RGBA, R, 1, G, 1, B, 1, D, 1, 0 } /* monochrome */ + }; + + g_return_val_if_fail (screen != NULL, NULL); + + display = gdk_screen_get_display (screen); + screen_num = gdk_screen_get_number (screen); + + gdk_error_trap_push (); + + visual = NULL; + for (i = 0; i < G_N_ELEMENTS (attrs); i++) + { + XVisualInfo *vi; + + vi = glXChooseVisual (GDK_DISPLAY_XDISPLAY (display), screen_num, attrs [i]); + + if (vi != NULL) + { + VisualID vid; + + vid = XVisualIDFromVisual (vi->visual); + + visual = gdkx_visual_get (vid); + + XFree (vi); + + if (visual != NULL) + { + break; + } + } + } + + gdk_display_sync (display); + gdk_error_trap_pop (); + +#else + visual = NULL; + +#endif /* HAVE_LIBGL */ + + return visual; +} diff --git a/src/gs-visual-gl.h b/src/gs-visual-gl.h new file mode 100644 index 0000000..fca138c --- /dev/null +++ b/src/gs-visual-gl.h @@ -0,0 +1,32 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#ifndef __GS_VISUAL_GL_H +#define __GS_VISUAL_GL_H + +#include + +G_BEGIN_DECLS + +GdkVisual *gs_visual_gl_get_best_for_screen (GdkScreen *screen); + +G_END_DECLS + +#endif /* __GS_VISUAL_GL_H */ diff --git a/src/gs-watcher-x11.c b/src/gs-watcher-x11.c new file mode 100644 index 0000000..1e3114e --- /dev/null +++ b/src/gs-watcher-x11.c @@ -0,0 +1,680 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * Copyright (C) 2008 Red Hat, Inc. + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "gs-watcher.h" +#include "gs-marshal.h" +#include "gs-debug.h" + +static void gs_watcher_class_init (GSWatcherClass *klass); +static void gs_watcher_init (GSWatcher *watcher); +static void gs_watcher_finalize (GObject *object); + +static gboolean watchdog_timer (GSWatcher *watcher); + +#define GS_WATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_WATCHER, GSWatcherPrivate)) + +struct GSWatcherPrivate +{ + /* settings */ + guint enabled : 1; + guint delta_notice_timeout; + + /* state */ + guint active : 1; + guint idle : 1; + guint idle_notice : 1; + + guint idle_id; + char *status_message; + + DBusGProxy *presence_proxy; + guint watchdog_timer_id; +}; + +enum +{ + PROP_0, + PROP_STATUS_MESSAGE +}; + +enum +{ + IDLE_CHANGED, + IDLE_NOTICE_CHANGED, + LAST_SIGNAL +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSWatcher, gs_watcher, G_TYPE_OBJECT) + +static void +remove_watchdog_timer (GSWatcher *watcher) +{ + if (watcher->priv->watchdog_timer_id != 0) + { + g_source_remove (watcher->priv->watchdog_timer_id); + watcher->priv->watchdog_timer_id = 0; + } +} + +static void +add_watchdog_timer (GSWatcher *watcher, + glong timeout) +{ + watcher->priv->watchdog_timer_id = g_timeout_add (timeout, + (GSourceFunc)watchdog_timer, + watcher); +} + +static void +gs_watcher_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSWatcher *self; + + self = GS_WATCHER (object); + + switch (prop_id) + { + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +set_status_text (GSWatcher *watcher, + const char *text) +{ + g_free (watcher->priv->status_message); + + watcher->priv->status_message = g_strdup (text); + g_object_notify (G_OBJECT (watcher), "status-message"); +} + +static void +gs_watcher_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSWatcher *self; + + self = GS_WATCHER (object); + + switch (prop_id) + { + case PROP_STATUS_MESSAGE: + set_status_text (self, g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_watcher_class_init (GSWatcherClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_watcher_finalize; + object_class->get_property = gs_watcher_get_property; + object_class->set_property = gs_watcher_set_property; + + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + signals [IDLE_CHANGED] = + g_signal_new ("idle-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWatcherClass, idle_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, G_TYPE_BOOLEAN); + signals [IDLE_NOTICE_CHANGED] = + g_signal_new ("idle-notice-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWatcherClass, idle_notice_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, G_TYPE_BOOLEAN); + + g_type_class_add_private (klass, sizeof (GSWatcherPrivate)); +} + +static gboolean +_gs_watcher_set_session_idle_notice (GSWatcher *watcher, + gboolean in_effect) +{ + gboolean res; + + res = FALSE; + + if (in_effect != watcher->priv->idle_notice) + { + + g_signal_emit (watcher, signals [IDLE_NOTICE_CHANGED], 0, in_effect, &res); + if (res) + { + gs_debug ("Changing idle notice state: %d", in_effect); + + watcher->priv->idle_notice = in_effect; + } + else + { + gs_debug ("Idle notice signal not handled: %d", in_effect); + } + } + + return res; +} + +static gboolean +_gs_watcher_set_session_idle (GSWatcher *watcher, + gboolean is_idle) +{ + gboolean res; + + res = FALSE; + + if (is_idle != watcher->priv->idle) + { + + g_signal_emit (watcher, signals [IDLE_CHANGED], 0, is_idle, &res); + if (res) + { + gs_debug ("Changing idle state: %d", is_idle); + + watcher->priv->idle = is_idle; + } + else + { + gs_debug ("Idle changed signal not handled: %d", is_idle); + } + } + + return res; +} + +gboolean +gs_watcher_get_active (GSWatcher *watcher) +{ + gboolean active; + + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + active = watcher->priv->active; + + return active; +} + +static void +_gs_watcher_reset_state (GSWatcher *watcher) +{ + watcher->priv->idle = FALSE; + watcher->priv->idle_notice = FALSE; +} + +static gboolean +_gs_watcher_set_active_internal (GSWatcher *watcher, + gboolean active) +{ + if (active != watcher->priv->active) + { + /* reset state */ + _gs_watcher_reset_state (watcher); + + watcher->priv->active = active; + } + + return TRUE; +} + +gboolean +gs_watcher_set_active (GSWatcher *watcher, + gboolean active) +{ + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + gs_debug ("turning watcher: %s", active ? "ON" : "OFF"); + + if (watcher->priv->active == active) + { + gs_debug ("Idle detection is already %s", + active ? "active" : "inactive"); + return FALSE; + } + + if (! watcher->priv->enabled) + { + gs_debug ("Idle detection is disabled, cannot activate"); + return FALSE; + } + + return _gs_watcher_set_active_internal (watcher, active); +} + +gboolean +gs_watcher_set_enabled (GSWatcher *watcher, + gboolean enabled) +{ + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + if (watcher->priv->enabled != enabled) + { + gboolean is_active = gs_watcher_get_active (watcher); + + watcher->priv->enabled = enabled; + + /* if we are disabling the watcher and we are + active shut it down */ + if (! enabled && is_active) + { + _gs_watcher_set_active_internal (watcher, FALSE); + } + } + + return TRUE; +} + +gboolean +gs_watcher_get_enabled (GSWatcher *watcher) +{ + gboolean enabled; + + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + enabled = watcher->priv->enabled; + + return enabled; +} + +static gboolean +on_idle_timeout (GSWatcher *watcher) +{ + gboolean res; + + res = _gs_watcher_set_session_idle (watcher, TRUE); + + _gs_watcher_set_session_idle_notice (watcher, FALSE); + + /* try again if we failed i guess */ + return !res; +} + +static void +set_status (GSWatcher *watcher, + guint status) +{ + gboolean res; + gboolean is_idle; + + if (! watcher->priv->active) + { + gs_debug ("GSWatcher: not active, ignoring status changes"); + return; + } + + is_idle = (status == 3); + + if (!is_idle && !watcher->priv->idle_notice) + { + /* no change in idleness */ + return; + } + + if (is_idle) + { + res = _gs_watcher_set_session_idle_notice (watcher, is_idle); + /* queue an activation */ + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + watcher->priv->idle_id = g_timeout_add (watcher->priv->delta_notice_timeout, + (GSourceFunc)on_idle_timeout, + watcher); + } + else + { + /* cancel notice too */ + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + res = _gs_watcher_set_session_idle (watcher, FALSE); + res = _gs_watcher_set_session_idle_notice (watcher, FALSE); + } +} + +static void +on_presence_status_changed (DBusGProxy *presence_proxy, + guint status, + GSWatcher *watcher) +{ + set_status (watcher, status); +} + +static void +on_presence_status_text_changed (DBusGProxy *presence_proxy, + const char *status_text, + GSWatcher *watcher) +{ + set_status_text (watcher, status_text); +} + +static gboolean +connect_presence_watcher (GSWatcher *watcher) +{ + DBusGConnection *bus; + GError *error; + gboolean ret; + + ret = FALSE; + + error = NULL; + bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); + if (bus == NULL) + { + g_warning ("Unable to get session bus: %s", error->message); + g_error_free (error); + goto done; + } + + error = NULL; + watcher->priv->presence_proxy = dbus_g_proxy_new_for_name_owner (bus, + "org.mate.SessionManager", + "/org/mate/SessionManager/Presence", + "org.mate.SessionManager.Presence", + &error); + if (watcher->priv->presence_proxy != NULL) + { + DBusGProxy *proxy; + + dbus_g_proxy_add_signal (watcher->priv->presence_proxy, + "StatusChanged", + G_TYPE_UINT, + G_TYPE_INVALID); + dbus_g_proxy_connect_signal (watcher->priv->presence_proxy, + "StatusChanged", + G_CALLBACK (on_presence_status_changed), + watcher, + NULL); + dbus_g_proxy_add_signal (watcher->priv->presence_proxy, + "StatusTextChanged", + G_TYPE_STRING, + G_TYPE_INVALID); + dbus_g_proxy_connect_signal (watcher->priv->presence_proxy, + "StatusTextChanged", + G_CALLBACK (on_presence_status_text_changed), + watcher, + NULL); + + proxy = dbus_g_proxy_new_from_proxy (watcher->priv->presence_proxy, + "org.freedesktop.DBus.Properties", + "/org/mate/SessionManager/Presence"); + if (proxy != NULL) + { + guint status; + const char *status_text; + GValue value = { 0, }; + + status = 0; + status_text = NULL; + + error = NULL; + dbus_g_proxy_call (proxy, + "Get", + &error, + G_TYPE_STRING, "org.mate.SessionManager.Presence", + G_TYPE_STRING, "status", + G_TYPE_INVALID, + G_TYPE_VALUE, &value, + G_TYPE_INVALID); + + if (error != NULL) + { + g_warning ("Couldn't get presence status: %s", error->message); + g_error_free (error); + goto done; + } + else + { + status = g_value_get_uint (&value); + } + + g_value_unset (&value); + + error = NULL; + dbus_g_proxy_call (proxy, + "Get", + &error, + G_TYPE_STRING, "org.mate.SessionManager.Presence", + G_TYPE_STRING, "status-text", + G_TYPE_INVALID, + G_TYPE_VALUE, &value, + G_TYPE_INVALID); + + if (error != NULL) + { + g_warning ("Couldn't get presence status text: %s", error->message); + g_error_free (error); + } + else + { + status_text = g_value_get_string (&value); + } + + set_status (watcher, status); + set_status_text (watcher, status_text); + } + } + else + { + g_warning ("Failed to get session presence proxy: %s", error->message); + g_error_free (error); + goto done; + } + + ret = TRUE; + +done: + return ret; +} + +static void +gs_watcher_init (GSWatcher *watcher) +{ + watcher->priv = GS_WATCHER_GET_PRIVATE (watcher); + + watcher->priv->enabled = TRUE; + watcher->priv->active = FALSE; + + connect_presence_watcher (watcher); + + /* time before idle signal to send notice signal */ + watcher->priv->delta_notice_timeout = 10000; + + add_watchdog_timer (watcher, 600000); +} + +static void +gs_watcher_finalize (GObject *object) +{ + GSWatcher *watcher; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_WATCHER (object)); + + watcher = GS_WATCHER (object); + + g_return_if_fail (watcher->priv != NULL); + + remove_watchdog_timer (watcher); + + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + + watcher->priv->active = FALSE; + + if (watcher->priv->presence_proxy != NULL) + { + g_object_unref (watcher->priv->presence_proxy); + } + + g_free (watcher->priv->status_message); + + G_OBJECT_CLASS (gs_watcher_parent_class)->finalize (object); +} + +/* Figuring out what the appropriate XSetScreenSaver() parameters are + (one wouldn't expect this to be rocket science.) +*/ +static void +disable_builtin_screensaver (GSWatcher *watcher, + gboolean unblank_screen) +{ + int current_server_timeout, current_server_interval; + int current_prefer_blank, current_allow_exp; + int desired_server_timeout, desired_server_interval; + int desired_prefer_blank, desired_allow_exp; + + XGetScreenSaver (GDK_DISPLAY (), + ¤t_server_timeout, + ¤t_server_interval, + ¤t_prefer_blank, + ¤t_allow_exp); + + desired_server_timeout = current_server_timeout; + desired_server_interval = current_server_interval; + desired_prefer_blank = current_prefer_blank; + desired_allow_exp = current_allow_exp; + + desired_server_interval = 0; + + /* I suspect (but am not sure) that DontAllowExposures might have + something to do with powering off the monitor as well, at least + on some systems that don't support XDPMS? Who know... */ + desired_allow_exp = AllowExposures; + + /* When we're not using an extension, set the server-side timeout to 0, + so that the server never gets involved with screen blanking, and we + do it all ourselves. (However, when we *are* using an extension, + we tell the server when to notify us, and rather than blanking the + screen, the server will send us an X event telling us to blank.) + */ + desired_server_timeout = 0; + + if (desired_server_timeout != current_server_timeout + || desired_server_interval != current_server_interval + || desired_prefer_blank != current_prefer_blank + || desired_allow_exp != current_allow_exp) + { + + gs_debug ("disabling server builtin screensaver:" + " (xset s %d %d; xset s %s; xset s %s)", + desired_server_timeout, + desired_server_interval, + (desired_prefer_blank ? "blank" : "noblank"), + (desired_allow_exp ? "expose" : "noexpose")); + + XSetScreenSaver (GDK_DISPLAY (), + desired_server_timeout, + desired_server_interval, + desired_prefer_blank, + desired_allow_exp); + + XSync (GDK_DISPLAY (), FALSE); + } + + if (unblank_screen) + { + /* Turn off the server builtin saver if it is now running. */ + XForceScreenSaver (GDK_DISPLAY (), ScreenSaverReset); + } +} + + +/* This timer goes off every few minutes, whether the user is idle or not, + to try and clean up anything that has gone wrong. + + It calls disable_builtin_screensaver() so that if xset has been used, + or some other program (like xlock) has messed with the XSetScreenSaver() + settings, they will be set back to sensible values (if a server extension + is in use, messing with xlock can cause the screensaver to never get a wakeup + event, and could cause monitor power-saving to occur, and all manner of + heinousness.) + + */ + +static gboolean +watchdog_timer (GSWatcher *watcher) +{ + + disable_builtin_screensaver (watcher, FALSE); + + return TRUE; +} + +GSWatcher * +gs_watcher_new (void) +{ + GSWatcher *watcher; + + watcher = g_object_new (GS_TYPE_WATCHER, + NULL); + + return GS_WATCHER (watcher); +} diff --git a/src/gs-watcher-x11.c.orig b/src/gs-watcher-x11.c.orig new file mode 100644 index 0000000..a9c90e8 --- /dev/null +++ b/src/gs-watcher-x11.c.orig @@ -0,0 +1,680 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * Copyright (C) 2008 Red Hat, Inc. + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "gs-watcher.h" +#include "gs-marshal.h" +#include "gs-debug.h" + +static void gs_watcher_class_init (GSWatcherClass *klass); +static void gs_watcher_init (GSWatcher *watcher); +static void gs_watcher_finalize (GObject *object); + +static gboolean watchdog_timer (GSWatcher *watcher); + +#define GS_WATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_WATCHER, GSWatcherPrivate)) + +struct GSWatcherPrivate +{ + /* settings */ + guint enabled : 1; + guint delta_notice_timeout; + + /* state */ + guint active : 1; + guint idle : 1; + guint idle_notice : 1; + + guint idle_id; + char *status_message; + + DBusGProxy *presence_proxy; + guint watchdog_timer_id; +}; + +enum +{ + PROP_0, + PROP_STATUS_MESSAGE +}; + +enum +{ + IDLE_CHANGED, + IDLE_NOTICE_CHANGED, + LAST_SIGNAL +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSWatcher, gs_watcher, G_TYPE_OBJECT) + +static void +remove_watchdog_timer (GSWatcher *watcher) +{ + if (watcher->priv->watchdog_timer_id != 0) + { + g_source_remove (watcher->priv->watchdog_timer_id); + watcher->priv->watchdog_timer_id = 0; + } +} + +static void +add_watchdog_timer (GSWatcher *watcher, + glong timeout) +{ + watcher->priv->watchdog_timer_id = g_timeout_add (timeout, + (GSourceFunc)watchdog_timer, + watcher); +} + +static void +gs_watcher_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSWatcher *self; + + self = GS_WATCHER (object); + + switch (prop_id) + { + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +set_status_text (GSWatcher *watcher, + const char *text) +{ + g_free (watcher->priv->status_message); + + watcher->priv->status_message = g_strdup (text); + g_object_notify (G_OBJECT (watcher), "status-message"); +} + +static void +gs_watcher_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSWatcher *self; + + self = GS_WATCHER (object); + + switch (prop_id) + { + case PROP_STATUS_MESSAGE: + set_status_text (self, g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_watcher_class_init (GSWatcherClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gs_watcher_finalize; + object_class->get_property = gs_watcher_get_property; + object_class->set_property = gs_watcher_set_property; + + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + signals [IDLE_CHANGED] = + g_signal_new ("idle-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWatcherClass, idle_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, G_TYPE_BOOLEAN); + signals [IDLE_NOTICE_CHANGED] = + g_signal_new ("idle-notice-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWatcherClass, idle_notice_changed), + NULL, + NULL, + gs_marshal_BOOLEAN__BOOLEAN, + G_TYPE_BOOLEAN, + 1, G_TYPE_BOOLEAN); + + g_type_class_add_private (klass, sizeof (GSWatcherPrivate)); +} + +static gboolean +_gs_watcher_set_session_idle_notice (GSWatcher *watcher, + gboolean in_effect) +{ + gboolean res; + + res = FALSE; + + if (in_effect != watcher->priv->idle_notice) + { + + g_signal_emit (watcher, signals [IDLE_NOTICE_CHANGED], 0, in_effect, &res); + if (res) + { + gs_debug ("Changing idle notice state: %d", in_effect); + + watcher->priv->idle_notice = in_effect; + } + else + { + gs_debug ("Idle notice signal not handled: %d", in_effect); + } + } + + return res; +} + +static gboolean +_gs_watcher_set_session_idle (GSWatcher *watcher, + gboolean is_idle) +{ + gboolean res; + + res = FALSE; + + if (is_idle != watcher->priv->idle) + { + + g_signal_emit (watcher, signals [IDLE_CHANGED], 0, is_idle, &res); + if (res) + { + gs_debug ("Changing idle state: %d", is_idle); + + watcher->priv->idle = is_idle; + } + else + { + gs_debug ("Idle changed signal not handled: %d", is_idle); + } + } + + return res; +} + +gboolean +gs_watcher_get_active (GSWatcher *watcher) +{ + gboolean active; + + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + active = watcher->priv->active; + + return active; +} + +static void +_gs_watcher_reset_state (GSWatcher *watcher) +{ + watcher->priv->idle = FALSE; + watcher->priv->idle_notice = FALSE; +} + +static gboolean +_gs_watcher_set_active_internal (GSWatcher *watcher, + gboolean active) +{ + if (active != watcher->priv->active) + { + /* reset state */ + _gs_watcher_reset_state (watcher); + + watcher->priv->active = active; + } + + return TRUE; +} + +gboolean +gs_watcher_set_active (GSWatcher *watcher, + gboolean active) +{ + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + gs_debug ("turning watcher: %s", active ? "ON" : "OFF"); + + if (watcher->priv->active == active) + { + gs_debug ("Idle detection is already %s", + active ? "active" : "inactive"); + return FALSE; + } + + if (! watcher->priv->enabled) + { + gs_debug ("Idle detection is disabled, cannot activate"); + return FALSE; + } + + return _gs_watcher_set_active_internal (watcher, active); +} + +gboolean +gs_watcher_set_enabled (GSWatcher *watcher, + gboolean enabled) +{ + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + if (watcher->priv->enabled != enabled) + { + gboolean is_active = gs_watcher_get_active (watcher); + + watcher->priv->enabled = enabled; + + /* if we are disabling the watcher and we are + active shut it down */ + if (! enabled && is_active) + { + _gs_watcher_set_active_internal (watcher, FALSE); + } + } + + return TRUE; +} + +gboolean +gs_watcher_get_enabled (GSWatcher *watcher) +{ + gboolean enabled; + + g_return_val_if_fail (GS_IS_WATCHER (watcher), FALSE); + + enabled = watcher->priv->enabled; + + return enabled; +} + +static gboolean +on_idle_timeout (GSWatcher *watcher) +{ + gboolean res; + + res = _gs_watcher_set_session_idle (watcher, TRUE); + + _gs_watcher_set_session_idle_notice (watcher, FALSE); + + /* try again if we failed i guess */ + return !res; +} + +static void +set_status (GSWatcher *watcher, + guint status) +{ + gboolean res; + gboolean is_idle; + + if (! watcher->priv->active) + { + gs_debug ("GSWatcher: not active, ignoring status changes"); + return; + } + + is_idle = (status == 3); + + if (!is_idle && !watcher->priv->idle_notice) + { + /* no change in idleness */ + return; + } + + if (is_idle) + { + res = _gs_watcher_set_session_idle_notice (watcher, is_idle); + /* queue an activation */ + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + watcher->priv->idle_id = g_timeout_add (watcher->priv->delta_notice_timeout, + (GSourceFunc)on_idle_timeout, + watcher); + } + else + { + /* cancel notice too */ + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + res = _gs_watcher_set_session_idle (watcher, FALSE); + res = _gs_watcher_set_session_idle_notice (watcher, FALSE); + } +} + +static void +on_presence_status_changed (DBusGProxy *presence_proxy, + guint status, + GSWatcher *watcher) +{ + set_status (watcher, status); +} + +static void +on_presence_status_text_changed (DBusGProxy *presence_proxy, + const char *status_text, + GSWatcher *watcher) +{ + set_status_text (watcher, status_text); +} + +static gboolean +connect_presence_watcher (GSWatcher *watcher) +{ + DBusGConnection *bus; + GError *error; + gboolean ret; + + ret = FALSE; + + error = NULL; + bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); + if (bus == NULL) + { + g_warning ("Unable to get session bus: %s", error->message); + g_error_free (error); + goto done; + } + + error = NULL; + watcher->priv->presence_proxy = dbus_g_proxy_new_for_name_owner (bus, + "org.mate.SessionManager", + "/org/mate/SessionManager/Presence", + "org.mate.SessionManager.Presence", + &error); + if (watcher->priv->presence_proxy != NULL) + { + DBusGProxy *proxy; + + dbus_g_proxy_add_signal (watcher->priv->presence_proxy, + "StatusChanged", + G_TYPE_UINT, + G_TYPE_INVALID); + dbus_g_proxy_connect_signal (watcher->priv->presence_proxy, + "StatusChanged", + G_CALLBACK (on_presence_status_changed), + watcher, + NULL); + dbus_g_proxy_add_signal (watcher->priv->presence_proxy, + "StatusTextChanged", + G_TYPE_STRING, + G_TYPE_INVALID); + dbus_g_proxy_connect_signal (watcher->priv->presence_proxy, + "StatusTextChanged", + G_CALLBACK (on_presence_status_text_changed), + watcher, + NULL); + + proxy = dbus_g_proxy_new_from_proxy (watcher->priv->presence_proxy, + "org.freedesktop.DBus.Properties", + "/org/mate/SessionManager/Presence"); + if (proxy != NULL) + { + guint status; + const char *status_text; + GValue value = { 0, }; + + status = 0; + status_text = NULL; + + error = NULL; + dbus_g_proxy_call (proxy, + "Get", + &error, + G_TYPE_STRING, "org.mate.SessionManager.Presence", + G_TYPE_STRING, "status", + G_TYPE_INVALID, + G_TYPE_VALUE, &value, + G_TYPE_INVALID); + + if (error != NULL) + { + g_warning ("Couldn't get presence status: %s", error->message); + g_error_free (error); + goto done; + } + else + { + status = g_value_get_uint (&value); + } + + g_value_unset (&value); + + error = NULL; + dbus_g_proxy_call (proxy, + "Get", + &error, + G_TYPE_STRING, "org.mate.SessionManager.Presence", + G_TYPE_STRING, "status-text", + G_TYPE_INVALID, + G_TYPE_VALUE, &value, + G_TYPE_INVALID); + + if (error != NULL) + { + g_warning ("Couldn't get presence status text: %s", error->message); + g_error_free (error); + } + else + { + status_text = g_value_get_string (&value); + } + + set_status (watcher, status); + set_status_text (watcher, status_text); + } + } + else + { + g_warning ("Failed to get session presence proxy: %s", error->message); + g_error_free (error); + goto done; + } + + ret = TRUE; + +done: + return ret; +} + +static void +gs_watcher_init (GSWatcher *watcher) +{ + watcher->priv = GS_WATCHER_GET_PRIVATE (watcher); + + watcher->priv->enabled = TRUE; + watcher->priv->active = FALSE; + + connect_presence_watcher (watcher); + + /* time before idle signal to send notice signal */ + watcher->priv->delta_notice_timeout = 10000; + + add_watchdog_timer (watcher, 600000); +} + +static void +gs_watcher_finalize (GObject *object) +{ + GSWatcher *watcher; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_WATCHER (object)); + + watcher = GS_WATCHER (object); + + g_return_if_fail (watcher->priv != NULL); + + remove_watchdog_timer (watcher); + + if (watcher->priv->idle_id > 0) + { + g_source_remove (watcher->priv->idle_id); + } + + watcher->priv->active = FALSE; + + if (watcher->priv->presence_proxy != NULL) + { + g_object_unref (watcher->priv->presence_proxy); + } + + g_free (watcher->priv->status_message); + + G_OBJECT_CLASS (gs_watcher_parent_class)->finalize (object); +} + +/* Figuring out what the appropriate XSetScreenSaver() parameters are + (one wouldn't expect this to be rocket science.) +*/ +static void +disable_builtin_screensaver (GSWatcher *watcher, + gboolean unblank_screen) +{ + int current_server_timeout, current_server_interval; + int current_prefer_blank, current_allow_exp; + int desired_server_timeout, desired_server_interval; + int desired_prefer_blank, desired_allow_exp; + + XGetScreenSaver (GDK_DISPLAY (), + ¤t_server_timeout, + ¤t_server_interval, + ¤t_prefer_blank, + ¤t_allow_exp); + + desired_server_timeout = current_server_timeout; + desired_server_interval = current_server_interval; + desired_prefer_blank = current_prefer_blank; + desired_allow_exp = current_allow_exp; + + desired_server_interval = 0; + + /* I suspect (but am not sure) that DontAllowExposures might have + something to do with powering off the monitor as well, at least + on some systems that don't support XDPMS? Who know... */ + desired_allow_exp = AllowExposures; + + /* When we're not using an extension, set the server-side timeout to 0, + so that the server never gets involved with screen blanking, and we + do it all ourselves. (However, when we *are* using an extension, + we tell the server when to notify us, and rather than blanking the + screen, the server will send us an X event telling us to blank.) + */ + desired_server_timeout = 0; + + if (desired_server_timeout != current_server_timeout + || desired_server_interval != current_server_interval + || desired_prefer_blank != current_prefer_blank + || desired_allow_exp != current_allow_exp) + { + + gs_debug ("disabling server builtin screensaver:" + " (xset s %d %d; xset s %s; xset s %s)", + desired_server_timeout, + desired_server_interval, + (desired_prefer_blank ? "blank" : "noblank"), + (desired_allow_exp ? "expose" : "noexpose")); + + XSetScreenSaver (GDK_DISPLAY (), + desired_server_timeout, + desired_server_interval, + desired_prefer_blank, + desired_allow_exp); + + XSync (GDK_DISPLAY (), FALSE); + } + + if (unblank_screen) + { + /* Turn off the server builtin saver if it is now running. */ + XForceScreenSaver (GDK_DISPLAY (), ScreenSaverReset); + } +} + + +/* This timer goes off every few minutes, whether the user is idle or not, + to try and clean up anything that has gone wrong. + + It calls disable_builtin_screensaver() so that if xset has been used, + or some other program (like xlock) has messed with the XSetScreenSaver() + settings, they will be set back to sensible values (if a server extension + is in use, messing with xlock can cause the screensaver to never get a wakeup + event, and could cause monitor power-saving to occur, and all manner of + heinousness.) + + */ + +static gboolean +watchdog_timer (GSWatcher *watcher) +{ + + disable_builtin_screensaver (watcher, FALSE); + + return TRUE; +} + +GSWatcher * +gs_watcher_new (void) +{ + GSWatcher *watcher; + + watcher = g_object_new (GS_TYPE_WATCHER, + NULL); + + return GS_WATCHER (watcher); +} diff --git a/src/gs-watcher.h b/src/gs-watcher.h new file mode 100644 index 0000000..be06bc7 --- /dev/null +++ b/src/gs-watcher.h @@ -0,0 +1,65 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_WATCHER_H +#define __GS_WATCHER_H + +G_BEGIN_DECLS + +#define GS_TYPE_WATCHER (gs_watcher_get_type ()) +#define GS_WATCHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_WATCHER, GSWatcher)) +#define GS_WATCHER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_WATCHER, GSWatcherClass)) +#define GS_IS_WATCHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_WATCHER)) +#define GS_IS_WATCHER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_WATCHER)) +#define GS_WATCHER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_WATCHER, GSWatcherClass)) + +typedef struct GSWatcherPrivate GSWatcherPrivate; + +typedef struct +{ + GObject parent; + GSWatcherPrivate *priv; +} GSWatcher; + +typedef struct +{ + GObjectClass parent_class; + + gboolean (* idle_changed) (GSWatcher *watcher, + gboolean is_idle); + gboolean (* idle_notice_changed) (GSWatcher *watcher, + gboolean in_effect); +} GSWatcherClass; + +GType gs_watcher_get_type (void); + +GSWatcher * gs_watcher_new (void); +gboolean gs_watcher_set_enabled (GSWatcher *watcher, + gboolean enabled); +gboolean gs_watcher_get_enabled (GSWatcher *watcher); +gboolean gs_watcher_set_active (GSWatcher *watcher, + gboolean active); +gboolean gs_watcher_get_active (GSWatcher *watcher); + +G_END_DECLS + +#endif /* __GS_WATCHER_H */ diff --git a/src/gs-watcher.h.orig b/src/gs-watcher.h.orig new file mode 100644 index 0000000..cc42dea --- /dev/null +++ b/src/gs-watcher.h.orig @@ -0,0 +1,65 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_WATCHER_H +#define __GS_WATCHER_H + +G_BEGIN_DECLS + +#define GS_TYPE_WATCHER (gs_watcher_get_type ()) +#define GS_WATCHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_WATCHER, GSWatcher)) +#define GS_WATCHER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_WATCHER, GSWatcherClass)) +#define GS_IS_WATCHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_WATCHER)) +#define GS_IS_WATCHER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_WATCHER)) +#define GS_WATCHER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_WATCHER, GSWatcherClass)) + +typedef struct GSWatcherPrivate GSWatcherPrivate; + +typedef struct +{ + GObject parent; + GSWatcherPrivate *priv; +} GSWatcher; + +typedef struct +{ + GObjectClass parent_class; + + gboolean (* idle_changed) (GSWatcher *watcher, + gboolean is_idle); + gboolean (* idle_notice_changed) (GSWatcher *watcher, + gboolean in_effect); +} GSWatcherClass; + +GType gs_watcher_get_type (void); + +GSWatcher * gs_watcher_new (void); +gboolean gs_watcher_set_enabled (GSWatcher *watcher, + gboolean enabled); +gboolean gs_watcher_get_enabled (GSWatcher *watcher); +gboolean gs_watcher_set_active (GSWatcher *watcher, + gboolean active); +gboolean gs_watcher_get_active (GSWatcher *watcher); + +G_END_DECLS + +#endif /* __GS_WATCHER_H */ diff --git a/src/gs-window-x11.c b/src/gs-window-x11.c new file mode 100644 index 0000000..2e6f0f7 --- /dev/null +++ b/src/gs-window-x11.c @@ -0,0 +1,2647 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2008 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-window.h" +#include "gs-marshal.h" +#include "subprocs.h" +#include "gs-debug.h" + +#ifdef HAVE_SHAPE_EXT +#include +#endif + +static void gs_window_class_init (GSWindowClass *klass); +static void gs_window_init (GSWindow *window); +static void gs_window_finalize (GObject *object); + +static gboolean popup_dialog_idle (GSWindow *window); +static void gs_window_dialog_finish (GSWindow *window); +static void remove_command_watches (GSWindow *window); + +enum +{ + DIALOG_RESPONSE_CANCEL, + DIALOG_RESPONSE_OK +}; + +#define MAX_QUEUED_EVENTS 16 +#define INFO_BAR_SECONDS 30 + +#define GS_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_WINDOW, GSWindowPrivate)) + +struct GSWindowPrivate +{ + int monitor; + + GdkRectangle geometry; + guint obscured : 1; + guint dialog_up : 1; + + guint lock_enabled : 1; + guint user_switch_enabled : 1; + guint logout_enabled : 1; + guint keyboard_enabled : 1; + + guint64 logout_timeout; + char *logout_command; + char *keyboard_command; + char *status_message; + + GtkWidget *vbox; + GtkWidget *drawing_area; + GtkWidget *lock_box; + GtkWidget *lock_socket; + GtkWidget *keyboard_socket; + GtkWidget *info_bar; + GtkWidget *info_content; + + GdkPixmap *background_pixmap; + + guint popup_dialog_idle_id; + + guint dialog_map_signal_id; + guint dialog_unmap_signal_id; + guint dialog_response_signal_id; + + guint watchdog_timer_id; + guint info_bar_timer_id; + + gint lock_pid; + gint lock_watch_id; + gint dialog_response; + gboolean dialog_quit_requested; + gboolean dialog_shake_in_progress; + + gint keyboard_pid; + gint keyboard_watch_id; + + GList *key_events; + + gdouble last_x; + gdouble last_y; + + GTimer *timer; + +#ifdef HAVE_SHAPE_EXT + int shape_event_base; +#endif +}; + +enum +{ + ACTIVITY, + DEACTIVATED, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_OBSCURED, + PROP_DIALOG_UP, + PROP_LOCK_ENABLED, + PROP_LOGOUT_ENABLED, + PROP_KEYBOARD_ENABLED, + PROP_KEYBOARD_COMMAND, + PROP_LOGOUT_COMMAND, + PROP_LOGOUT_TIMEOUT, + PROP_MONITOR, + PROP_STATUS_MESSAGE +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSWindow, gs_window, GTK_TYPE_WINDOW) + +static void +set_invisible_cursor (GdkWindow *window, + gboolean invisible) +{ + GdkBitmap *empty_bitmap; + GdkCursor *cursor = NULL; + GdkColor useless; + char invisible_cursor_bits [] = { 0x0 }; + + if (invisible) + { + useless.red = useless.green = useless.blue = 0; + useless.pixel = 0; + + empty_bitmap = gdk_bitmap_create_from_data (window, + invisible_cursor_bits, + 1, 1); + + cursor = gdk_cursor_new_from_pixmap (empty_bitmap, + empty_bitmap, + &useless, + &useless, 0, 0); + + g_object_unref (empty_bitmap); + } + + gdk_window_set_cursor (window, cursor); + + if (cursor) + { + gdk_cursor_unref (cursor); + } +} + +/* derived from tomboy */ +static void +gs_window_override_user_time (GSWindow *window) +{ + guint32 ev_time = gtk_get_current_event_time (); + + if (ev_time == 0) + { + gint ev_mask = gtk_widget_get_events (GTK_WIDGET (window)); + if (!(ev_mask & GDK_PROPERTY_CHANGE_MASK)) + { + gtk_widget_add_events (GTK_WIDGET (window), + GDK_PROPERTY_CHANGE_MASK); + } + + /* + * NOTE: Last resort for D-BUS or other non-interactive + * openings. Causes roundtrip to server. Lame. + */ + ev_time = gdk_x11_get_server_time (GTK_WIDGET (window)->window); + } + + gdk_x11_window_set_user_time (GTK_WIDGET (window)->window, ev_time); +} + +static void +force_no_pixmap_background (GtkWidget *widget) +{ + static gboolean first_time = TRUE; + + if (first_time) + { + gtk_rc_parse_string ("\n" + " style \"gs-theme-engine-style\"\n" + " {\n" + " bg_pixmap[NORMAL] = \"\"\n" + " bg_pixmap[INSENSITIVE] = \"\"\n" + " bg_pixmap[ACTIVE] = \"\"\n" + " bg_pixmap[PRELIGHT] = \"\"\n" + " bg[NORMAL] = { 0.0, 0.0, 0.0 }\n" + " bg[INSENSITIVE] = { 0.0, 0.0, 0.0 }\n" + " bg[ACTIVE] = { 0.0, 0.0, 0.0 }\n" + " bg[PRELIGHT] = { 0.0, 0.0, 0.0 }\n" + " }\n" + " widget \"gs-window-drawing-area*\" style : highest \"gs-theme-engine-style\"\n" + "\n"); + first_time = FALSE; + } + + gtk_widget_set_name (widget, "gs-window-drawing-area"); +} + +static void +clear_children (Window window) +{ + Window root; + Window parent; + Window *children; + unsigned int n_children; + int status; + + children = NULL; + status = XQueryTree (GDK_DISPLAY (), window, &root, &parent, &children, &n_children); + + if (status == 0) + { + if (children) + { + XFree (children); + } + return; + } + + if (children) + { + while (n_children) + { + Window child; + + child = children [--n_children]; + + XClearWindow (GDK_DISPLAY (), child); + clear_children (child); + } + + XFree (children); + } +} + +static void +widget_clear_all_children (GtkWidget *widget) +{ + GdkWindow *w; + + gs_debug ("Clearing all child windows"); + + gdk_error_trap_push (); + + w = widget->window; + + clear_children (GDK_WINDOW_XID (w)); + + gdk_display_sync (gtk_widget_get_display (widget)); + gdk_error_trap_pop (); +} + +void +gs_window_set_background_pixmap (GSWindow *window, + GdkPixmap *pixmap) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->background_pixmap != NULL) + { + g_object_unref (window->priv->background_pixmap); + } + + if (pixmap != NULL) + { + window->priv->background_pixmap = g_object_ref (pixmap); + gdk_window_set_back_pixmap (GTK_WIDGET (window)->window, + pixmap, + FALSE); + } +} + +static void +gs_window_clear_to_background_pixmap (GSWindow *window) +{ + GtkStateType state; + GtkStyle *style; + + g_return_if_fail (GS_IS_WINDOW (window)); + + if (! GTK_WIDGET_VISIBLE (GTK_WIDGET (window))) + { + return; + } + + if (window->priv->background_pixmap == NULL) + { + /* don't allow null pixmaps */ + return; + } + + gs_debug ("Clearing window to background pixmap"); + + style = gtk_style_copy (GTK_WIDGET (window)->style); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (GTK_WIDGET (window)->style->bg_pixmap)) + { + + if (style->bg_pixmap[state] != NULL) + { + g_object_unref (style->bg_pixmap[state]); + } + + style->bg_pixmap[state] = g_object_ref (window->priv->background_pixmap); + state++; + } + + gtk_widget_set_style (GTK_WIDGET (window), style); + g_object_unref (style); + + if (window->priv->background_pixmap != NULL) + { + gdk_window_set_back_pixmap (GTK_WIDGET (window)->window, + window->priv->background_pixmap, + FALSE); + } + + gdk_window_clear (GTK_WIDGET (window)->window); + + gdk_flush (); +} + +static void +clear_widget (GtkWidget *widget) +{ + GdkColor color = { 0, 0x0000, 0x0000, 0x0000 }; + GdkColormap *colormap; + GtkStateType state; + GtkStyle *style; + + if (! GTK_WIDGET_VISIBLE (widget)) + { + return; + } + + gs_debug ("Clearing widget"); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg)) + { + gtk_widget_modify_bg (widget, state, &color); + state++; + } + + style = gtk_style_copy (widget->style); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg_pixmap)) + { + + if (style->bg_pixmap[state] != NULL) + { + g_object_unref (style->bg_pixmap[state]); + } + + style->bg_pixmap[state] = NULL; + state++; + } + + colormap = gdk_drawable_get_colormap (widget->window); + gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE); + gdk_window_set_background (widget->window, &color); + + gtk_widget_set_style (widget, style); + g_object_unref (style); + + gdk_window_clear (widget->window); + + /* If a screensaver theme adds child windows we need to clear them too */ + widget_clear_all_children (widget); + + gdk_flush (); +} + +void +gs_window_clear (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + clear_widget (GTK_WIDGET (window)); + clear_widget (window->priv->drawing_area); +} + +static GdkRegion * +get_outside_region (GSWindow *window) +{ + int i; + GdkRegion *region; + + region = gdk_region_new (); + for (i = 0; i < window->priv->monitor; i++) + { + GdkRectangle geometry; + + gdk_screen_get_monitor_geometry (GTK_WINDOW (window)->screen, + i, &geometry); + gdk_region_union_with_rect (region, &geometry); + } + + return region; +} + +static void +update_geometry (GSWindow *window) +{ + GdkRectangle geometry; + GdkRegion *outside_region; + GdkRegion *monitor_region; + + outside_region = get_outside_region (window); + + gdk_screen_get_monitor_geometry (GTK_WINDOW (window)->screen, + window->priv->monitor, + &geometry); + gs_debug ("got geometry for monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + geometry.x, + geometry.y, + geometry.width, + geometry.height); + monitor_region = gdk_region_rectangle (&geometry); + gdk_region_subtract (monitor_region, outside_region); + gdk_region_destroy (outside_region); + + gdk_region_get_clipbox (monitor_region, &geometry); + gdk_region_destroy (monitor_region); + + gs_debug ("using geometry for monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + geometry.x, + geometry.y, + geometry.width, + geometry.height); + + window->priv->geometry.x = geometry.x; + window->priv->geometry.y = geometry.y; + window->priv->geometry.width = geometry.width; + window->priv->geometry.height = geometry.height; +} + +static void +screen_size_changed (GdkScreen *screen, + GSWindow *window) +{ + gs_debug ("Got screen size changed signal"); + gtk_widget_queue_resize (GTK_WIDGET (window)); +} + +/* copied from panel-toplevel.c */ +static void +gs_window_move_resize_window (GSWindow *window, + gboolean move, + gboolean resize) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (window); + + g_assert (GTK_WIDGET_REALIZED (widget)); + + gs_debug ("Move and/or resize window on monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + window->priv->geometry.x, + window->priv->geometry.y, + window->priv->geometry.width, + window->priv->geometry.height); + + if (move && resize) + { + gdk_window_move_resize (widget->window, + window->priv->geometry.x, + window->priv->geometry.y, + window->priv->geometry.width, + window->priv->geometry.height); + } + else if (move) + { + gdk_window_move (widget->window, + window->priv->geometry.x, + window->priv->geometry.y); + } + else if (resize) + { + gdk_window_resize (widget->window, + window->priv->geometry.width, + window->priv->geometry.height); + } +} + +static void +gs_window_real_unrealize (GtkWidget *widget) +{ + g_signal_handlers_disconnect_by_func (gtk_window_get_screen (GTK_WINDOW (widget)), + screen_size_changed, + widget); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->unrealize) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->unrealize (widget); + } +} + +/* copied from gdk */ +extern char **environ; + +static gchar ** +spawn_make_environment_for_screen (GdkScreen *screen, + gchar **envp) +{ + gchar **retval = NULL; + gchar *display_name; + gint display_index = -1; + gint i, env_len; + + g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); + + if (envp == NULL) + envp = environ; + + for (env_len = 0; envp[env_len]; env_len++) + if (strncmp (envp[env_len], "DISPLAY", strlen ("DISPLAY")) == 0) + display_index = env_len; + + retval = g_new (char *, env_len + 1); + retval[env_len] = NULL; + + display_name = gdk_screen_make_display_name (screen); + + for (i = 0; i < env_len; i++) + if (i == display_index) + retval[i] = g_strconcat ("DISPLAY=", display_name, NULL); + else + retval[i] = g_strdup (envp[i]); + + g_assert (i == env_len); + + g_free (display_name); + + return retval; +} + +static gboolean +spawn_command_line_on_screen_sync (GdkScreen *screen, + const gchar *command_line, + char **standard_output, + char **standard_error, + int *exit_status, + GError **error) +{ + char **argv = NULL; + char **envp = NULL; + gboolean retval; + + g_return_val_if_fail (command_line != NULL, FALSE); + + if (! g_shell_parse_argv (command_line, NULL, &argv, error)) + { + return FALSE; + } + + envp = spawn_make_environment_for_screen (screen, NULL); + + retval = g_spawn_sync (NULL, + argv, + envp, + G_SPAWN_SEARCH_PATH, + NULL, + NULL, + standard_output, + standard_error, + exit_status, + error); + + g_strfreev (argv); + g_strfreev (envp); + + return retval; +} + +static GdkVisual * +get_best_visual_for_screen (GdkScreen *screen) +{ + 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; + std_output = NULL; + res = spawn_command_line_on_screen_sync (screen, + command, + &std_output, + NULL, + &exit_status, + &error); + if (! res) + { + gs_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); + + gs_debug ("Found best GL visual for screen %d: 0x%x", + gdk_screen_get_number (screen), + (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_for_screen (screen); + + 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 void +gs_window_real_realize (GtkWidget *widget) +{ + widget_set_best_colormap (widget); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->realize) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->realize (widget); + } + + gs_window_override_user_time (GS_WINDOW (widget)); + + gs_window_move_resize_window (GS_WINDOW (widget), TRUE, TRUE); + + g_signal_connect (gtk_window_get_screen (GTK_WINDOW (widget)), + "size_changed", + G_CALLBACK (screen_size_changed), + widget); +} + +/* every so often we should raise the window in case + another window has somehow gotten on top */ +static gboolean +watchdog_timer (GSWindow *window) +{ + GtkWidget *widget = GTK_WIDGET (window); + + gdk_window_focus (widget->window, GDK_CURRENT_TIME); + + return TRUE; +} + +static void +remove_watchdog_timer (GSWindow *window) +{ + if (window->priv->watchdog_timer_id != 0) + { + g_source_remove (window->priv->watchdog_timer_id); + window->priv->watchdog_timer_id = 0; + } +} + +static void +add_watchdog_timer (GSWindow *window, + glong timeout) +{ + window->priv->watchdog_timer_id = g_timeout_add (timeout, + (GSourceFunc)watchdog_timer, + window); +} + +static void +remove_popup_dialog_idle (GSWindow *window) +{ + if (window->priv->popup_dialog_idle_id != 0) + { + g_source_remove (window->priv->popup_dialog_idle_id); + window->priv->popup_dialog_idle_id = 0; + } +} + +static void +add_popup_dialog_idle (GSWindow *window) +{ + window->priv->popup_dialog_idle_id = g_idle_add ((GSourceFunc)popup_dialog_idle, window); +} + +static gboolean +emit_deactivated_idle (GSWindow *window) +{ + g_signal_emit (window, signals [DEACTIVATED], 0); + + return FALSE; +} + +static void +add_emit_deactivated_idle (GSWindow *window) +{ + g_idle_add ((GSourceFunc)emit_deactivated_idle, window); +} + +static void +gs_window_raise (GSWindow *window) +{ + GdkWindow *win; + + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Raising screensaver window"); + + win = GTK_WIDGET (window)->window; + + gdk_window_raise (win); +} + +static gboolean +x11_window_is_ours (Window window) +{ + GdkWindow *gwindow; + gboolean ret; + + ret = FALSE; + + gwindow = gdk_window_lookup (window); + if (gwindow && (window != GDK_ROOT_WINDOW ())) + { + ret = TRUE; + } + + return ret; +} + +#ifdef HAVE_SHAPE_EXT +static void +unshape_window (GSWindow *window) +{ + gdk_window_shape_combine_region (GTK_WIDGET (window)->window, + NULL, + 0, + 0); +} +#endif + +static void +gs_window_xevent (GSWindow *window, + GdkXEvent *xevent) +{ + XEvent *ev; + + ev = xevent; + + /* MapNotify is used to tell us when new windows are mapped. + ConfigureNofify is used to tell us when windows are raised. */ + switch (ev->xany.type) + { + case MapNotify: + { + XMapEvent *xme = &ev->xmap; + + if (! x11_window_is_ours (xme->window)) + { + gs_window_raise (window); + } + else + { + gs_debug ("not raising our windows"); + } + + break; + } + case ConfigureNotify: + { + XConfigureEvent *xce = &ev->xconfigure; + + if (! x11_window_is_ours (xce->window)) + { + gs_window_raise (window); + } + else + { + gs_debug ("not raising our windows"); + } + + break; + } + default: + /* extension events */ +#ifdef HAVE_SHAPE_EXT + if (ev->xany.type == (window->priv->shape_event_base + ShapeNotify)) + { + /*XShapeEvent *xse = (XShapeEvent *) ev;*/ + unshape_window (window); + gs_debug ("Window was reshaped!"); + } +#endif + + break; + } + +} + +static GdkFilterReturn +xevent_filter (GdkXEvent *xevent, + GdkEvent *event, + GSWindow *window) +{ + gs_window_xevent (window, xevent); + + return GDK_FILTER_CONTINUE; +} + +static void +select_popup_events (void) +{ + XWindowAttributes attr; + unsigned long events; + + gdk_error_trap_push (); + + memset (&attr, 0, sizeof (attr)); + XGetWindowAttributes (GDK_DISPLAY (), GDK_ROOT_WINDOW (), &attr); + + events = SubstructureNotifyMask | attr.your_event_mask; + XSelectInput (GDK_DISPLAY (), GDK_ROOT_WINDOW (), events); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +} + +static void +window_select_shape_events (GSWindow *window) +{ +#ifdef HAVE_SHAPE_EXT + unsigned long events; + int shape_error_base; + + gdk_error_trap_push (); + + if (XShapeQueryExtension (GDK_DISPLAY (), &window->priv->shape_event_base, &shape_error_base)) + { + events = ShapeNotifyMask; + XShapeSelectInput (GDK_DISPLAY (), GDK_WINDOW_XID (GTK_WIDGET (window)->window), events); + } + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +#endif +} + +static void +gs_window_real_show (GtkWidget *widget) +{ + GSWindow *window; + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->show) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->show (widget); + } + + gs_window_clear (GS_WINDOW (widget)); + + set_invisible_cursor (widget->window, TRUE); + + window = GS_WINDOW (widget); + if (window->priv->timer) + { + g_timer_destroy (window->priv->timer); + } + window->priv->timer = g_timer_new (); + + remove_watchdog_timer (window); + add_watchdog_timer (window, 30000); + + select_popup_events (); + window_select_shape_events (window); + gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, window); +} + +static void +set_info_text_and_icon (GSWindow *window, + const char *icon_stock_id, + const char *primary_text, + const char *secondary_text) +{ + GtkWidget *content_area; + GtkWidget *hbox_content; + GtkWidget *image; + GtkWidget *vbox; + gchar *primary_markup; + gchar *secondary_markup; + GtkWidget *primary_label; + GtkWidget *secondary_label; + + hbox_content = gtk_hbox_new (FALSE, 8); + gtk_widget_show (hbox_content); + + image = gtk_image_new_from_stock (icon_stock_id, GTK_ICON_SIZE_DIALOG); + gtk_widget_show (image); + gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0); + gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_widget_show (vbox); + gtk_box_pack_start (GTK_BOX (hbox_content), vbox, FALSE, FALSE, 0); + + primary_markup = g_strdup_printf ("%s", primary_text); + primary_label = gtk_label_new (primary_markup); + g_free (primary_markup); + gtk_widget_show (primary_label); + gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0); + gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE); + gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5); + + if (secondary_text != NULL) + { + secondary_markup = g_strdup_printf ("%s", + secondary_text); + secondary_label = gtk_label_new (secondary_markup); + g_free (secondary_markup); + gtk_widget_show (secondary_label); + gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0); + gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE); + gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5); + } + + /* remove old content */ + content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (window->priv->info_bar)); + if (window->priv->info_content != NULL) + { + gtk_container_remove (GTK_CONTAINER (content_area), window->priv->info_content); + } + gtk_box_pack_start (GTK_BOX (content_area), + hbox_content, + TRUE, FALSE, 0); + window->priv->info_content = hbox_content; +} + +static gboolean +info_bar_timeout (GSWindow *window) +{ + window->priv->info_bar_timer_id = 0; + gtk_widget_hide (window->priv->info_bar); + return FALSE; +} + +void +gs_window_show_message (GSWindow *window, + const char *summary, + const char *body, + const char *icon) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + set_info_text_and_icon (window, + icon, + summary, + body); + gtk_widget_show (window->priv->info_bar); + + if (window->priv->info_bar_timer_id > 0) + { + g_source_remove (window->priv->info_bar_timer_id); + } + + window->priv->info_bar_timer_id = g_timeout_add_seconds (INFO_BAR_SECONDS, + (GSourceFunc)info_bar_timeout, + window); +} + +void +gs_window_show (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gtk_widget_show (GTK_WIDGET (window)); +} + +static void +gs_window_real_hide (GtkWidget *widget) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + + gdk_window_remove_filter (NULL, (GdkFilterFunc)xevent_filter, window); + + remove_watchdog_timer (window); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->hide) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->hide (widget); + } +} + +void +gs_window_destroy (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_window_cancel_unlock_request (window); + + gtk_widget_destroy (GTK_WIDGET (window)); +} + +GdkWindow * +gs_window_get_gdk_window (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return GTK_WIDGET (window)->window; +} + +GtkWidget * +gs_window_get_drawing_area (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return window->priv->drawing_area; +} + +/* just for debugging */ +static gboolean +error_watch (GIOChannel *source, + GIOCondition condition, + gpointer data) +{ + gboolean finished = FALSE; + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + gs_debug ("command error output: %s", line); + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +spawn_on_window (GSWindow *window, + char *command, + int *pid, + GIOFunc watch_func, + gpointer user_data, + gint *watch_id) +{ + int argc; + char **argv; + GError *error; + gboolean result; + GIOChannel *channel; + int standard_output; + int standard_error; + int child_pid; + int id; + + error = NULL; + if (! g_shell_parse_argv (command, &argc, &argv, &error)) + { + gs_debug ("Could not parse command: %s", error->message); + g_error_free (error); + return FALSE; + } + + error = NULL; + result = gdk_spawn_on_screen_with_pipes (GTK_WINDOW (window)->screen, + NULL, + argv, + NULL, + G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH, + NULL, + NULL, + &child_pid, + NULL, + &standard_output, + &standard_error, + &error); + + if (! result) + { + gs_debug ("Could not start command '%s': %s", command, error->message); + g_error_free (error); + g_strfreev (argv); + return FALSE; + } + + if (pid != NULL) + { + *pid = child_pid; + } + else + { + g_spawn_close_pid (child_pid); + } + + /* output channel */ + channel = g_io_channel_unix_new (standard_output); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + watch_func, + user_data); + if (watch_id != NULL) + { + *watch_id = id; + } + g_io_channel_unref (channel); + + /* error channel */ + channel = g_io_channel_unix_new (standard_error); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + error_watch, + NULL); + g_io_channel_unref (channel); + + g_strfreev (argv); + + return result; +} + +static void +lock_plug_added (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_show (widget); +} + +static gboolean +lock_plug_removed (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_hide (widget); + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->lock_box)); + window->priv->lock_box = NULL; + + return TRUE; +} + +static void +keyboard_plug_added (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_show (widget); +} + +static gboolean +keyboard_plug_removed (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_hide (widget); + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->keyboard_socket)); + + return TRUE; +} + +static void +keyboard_socket_destroyed (GtkWidget *widget, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (widget, keyboard_socket_destroyed, window); + g_signal_handlers_disconnect_by_func (widget, keyboard_plug_added, window); + g_signal_handlers_disconnect_by_func (widget, keyboard_plug_removed, window); + + window->priv->keyboard_socket = NULL; +} + +static void +forward_key_events (GSWindow *window) +{ + window->priv->key_events = g_list_reverse (window->priv->key_events); + + while (window->priv->key_events != NULL) + { + GdkEventKey *event = window->priv->key_events->data; + + gtk_window_propagate_key_event (GTK_WINDOW (window), event); + + gdk_event_free ((GdkEvent *)event); + window->priv->key_events = g_list_delete_link (window->priv->key_events, + window->priv->key_events); + } +} + +static void +remove_key_events (GSWindow *window) +{ + window->priv->key_events = g_list_reverse (window->priv->key_events); + + while (window->priv->key_events) + { + GdkEventKey *event = window->priv->key_events->data; + + gdk_event_free ((GdkEvent *)event); + window->priv->key_events = g_list_delete_link (window->priv->key_events, + window->priv->key_events); + } +} + +static void +lock_socket_show (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_child_focus (window->priv->lock_socket, GTK_DIR_TAB_FORWARD); + + /* send queued events to the dialog */ + forward_key_events (window); +} + +static void +lock_socket_destroyed (GtkWidget *widget, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (widget, lock_socket_show, window); + g_signal_handlers_disconnect_by_func (widget, lock_socket_destroyed, window); + g_signal_handlers_disconnect_by_func (widget, lock_plug_added, window); + g_signal_handlers_disconnect_by_func (widget, lock_plug_removed, window); + + window->priv->lock_socket = NULL; +} + +static void +create_keyboard_socket (GSWindow *window, + guint32 id) +{ + int height; + + height = (gdk_screen_get_height (gtk_widget_get_screen (GTK_WIDGET (window)))) / 4; + + window->priv->keyboard_socket = gtk_socket_new (); + gtk_widget_set_size_request (window->priv->keyboard_socket, -1, height); + + g_signal_connect (window->priv->keyboard_socket, "destroy", + G_CALLBACK (keyboard_socket_destroyed), window); + g_signal_connect (window->priv->keyboard_socket, "plug_added", + G_CALLBACK (keyboard_plug_added), window); + g_signal_connect (window->priv->keyboard_socket, "plug_removed", + G_CALLBACK (keyboard_plug_removed), window); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->keyboard_socket, FALSE, FALSE, 0); + gtk_socket_add_id (GTK_SOCKET (window->priv->keyboard_socket), id); +} + +/* adapted from gspawn.c */ +static int +wait_on_child (int pid) +{ + int status; + +wait_again: + if (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + goto wait_again; + } + else if (errno == ECHILD) + { + ; /* do nothing, child already reaped */ + } + else + { + gs_debug ("waitpid () should not fail in 'GSWindow'"); + } + } + + return status; +} + +static void +kill_keyboard_command (GSWindow *window) +{ + if (window->priv->keyboard_pid > 0) + { + signal_pid (window->priv->keyboard_pid, SIGTERM); + } +} + +static void +kill_dialog_command (GSWindow *window) +{ + /* If a dialog is up we need to signal it + and wait on it */ + if (window->priv->lock_pid > 0) + { + signal_pid (window->priv->lock_pid, SIGTERM); + } +} + +static void +keyboard_command_finish (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + /* send a signal just in case */ + kill_keyboard_command (window); + + gs_debug ("Keyboard finished"); + + if (window->priv->keyboard_pid > 0) + { + int exit_status; + + exit_status = wait_on_child (window->priv->keyboard_pid); + + g_spawn_close_pid (window->priv->keyboard_pid); + window->priv->keyboard_pid = 0; + } +} + +static gboolean +keyboard_command_watch (GIOChannel *source, + GIOCondition condition, + GSWindow *window) +{ + gboolean finished = FALSE; + + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + { + guint32 id; + char c; + gs_debug ("keyboard command output: %s", line); + if (1 == sscanf (line, " %" G_GUINT32_FORMAT " %c", &id, &c)) + { + create_keyboard_socket (window, id); + } + } + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + window->priv->keyboard_watch_id = 0; + keyboard_command_finish (window); + return FALSE; + } + + return TRUE; +} + +static void +embed_keyboard (GSWindow *window) +{ + gboolean res; + + if (! window->priv->keyboard_enabled + || window->priv->keyboard_command == NULL) + return; + + gs_debug ("Adding embedded keyboard widget"); + + /* FIXME: verify command is safe */ + + gs_debug ("Running command: %s", window->priv->keyboard_command); + + res = spawn_on_window (window, + window->priv->keyboard_command, + &window->priv->keyboard_pid, + (GIOFunc)keyboard_command_watch, + window, + &window->priv->keyboard_watch_id); + if (! res) + { + gs_debug ("Could not start command: %s", window->priv->keyboard_command); + } +} + +static void +create_lock_socket (GSWindow *window, + guint32 id) +{ + window->priv->lock_socket = gtk_socket_new (); + window->priv->lock_box = gtk_alignment_new (0.5, 0.5, 0, 0); + gtk_widget_show (window->priv->lock_box); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->lock_box, TRUE, TRUE, 0); + + gtk_container_add (GTK_CONTAINER (window->priv->lock_box), window->priv->lock_socket); + + g_signal_connect (window->priv->lock_socket, "show", + G_CALLBACK (lock_socket_show), window); + g_signal_connect (window->priv->lock_socket, "destroy", + G_CALLBACK (lock_socket_destroyed), window); + g_signal_connect (window->priv->lock_socket, "plug_added", + G_CALLBACK (lock_plug_added), window); + g_signal_connect (window->priv->lock_socket, "plug_removed", + G_CALLBACK (lock_plug_removed), window); + + gtk_socket_add_id (GTK_SOCKET (window->priv->lock_socket), id); + + if (window->priv->keyboard_enabled) + { + embed_keyboard (window); + } +} + +static void +gs_window_dialog_finish (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Dialog finished"); + + /* make sure we finish the keyboard thing too */ + keyboard_command_finish (window); + + /* send a signal just in case */ + kill_dialog_command (window); + + if (window->priv->lock_pid > 0) + { + int exit_status; + + exit_status = wait_on_child (window->priv->lock_pid); + + g_spawn_close_pid (window->priv->lock_pid); + window->priv->lock_pid = 0; + } + + /* remove events for the case were we failed to show socket */ + remove_key_events (window); +} + +static void +maybe_kill_dialog (GSWindow *window) +{ + if (!window->priv->dialog_shake_in_progress + && window->priv->dialog_quit_requested + && window->priv->lock_pid > 0) + { + kill (window->priv->lock_pid, SIGTERM); + } +} + +/* very rudimentary animation for indicating an auth failure */ +static void +shake_dialog (GSWindow *window) +{ + int i; + guint left; + guint right; + + window->priv->dialog_shake_in_progress = TRUE; + + for (i = 0; i < 9; i++) + { + if (i % 2 == 0) + { + left = 30; + right = 0; + } + else + { + left = 0; + right = 30; + } + + if (! window->priv->lock_box) + { + break; + } + + gtk_alignment_set_padding (GTK_ALIGNMENT (window->priv->lock_box), + 0, 0, + left, + right); + + while (gtk_events_pending ()) + { + gtk_main_iteration (); + } + + g_usleep (10000); + } + + window->priv->dialog_shake_in_progress = FALSE; + maybe_kill_dialog (window); +} + +static void +window_set_dialog_up (GSWindow *window, + gboolean dialog_up) +{ + if (window->priv->dialog_up == dialog_up) + { + return; + } + + window->priv->dialog_up = dialog_up; + g_object_notify (G_OBJECT (window), "dialog-up"); +} + +static void +popdown_dialog (GSWindow *window) +{ + gs_window_dialog_finish (window); + + gtk_widget_show (window->priv->drawing_area); + + gs_window_clear (window); + set_invisible_cursor (GTK_WIDGET (window)->window, TRUE); + + window_set_dialog_up (window, FALSE); + + /* reset the pointer positions */ + window->priv->last_x = -1; + window->priv->last_y = -1; + + if (window->priv->lock_box != NULL) + { + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->lock_box)); + window->priv->lock_box = NULL; + } + + remove_popup_dialog_idle (window); + remove_command_watches (window); +} + +static gboolean +lock_command_watch (GIOChannel *source, + GIOCondition condition, + GSWindow *window) +{ + gboolean finished = FALSE; + + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + gs_debug ("command output: %s", line); + + if (strstr (line, "WINDOW ID=") != NULL) + { + guint32 id; + char c; + if (1 == sscanf (line, " WINDOW ID= %" G_GUINT32_FORMAT " %c", &id, &c)) + { + create_lock_socket (window, id); + } + } + else if (strstr (line, "NOTICE=") != NULL) + { + if (strstr (line, "NOTICE=AUTH FAILED") != NULL) + { + shake_dialog (window); + } + } + else if (strstr (line, "RESPONSE=") != NULL) + { + if (strstr (line, "RESPONSE=OK") != NULL) + { + gs_debug ("Got OK response"); + window->priv->dialog_response = DIALOG_RESPONSE_OK; + } + else + { + gs_debug ("Got CANCEL response"); + window->priv->dialog_response = DIALOG_RESPONSE_CANCEL; + } + finished = TRUE; + } + else if (strstr (line, "REQUEST QUIT") != NULL) + { + gs_debug ("Got request for quit"); + window->priv->dialog_quit_requested = TRUE; + maybe_kill_dialog (window); + } + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + popdown_dialog (window); + + if (window->priv->dialog_response == DIALOG_RESPONSE_OK) + { + add_emit_deactivated_idle (window); + } + + window->priv->lock_watch_id = 0; + + return FALSE; + } + + return TRUE; +} + +static gboolean +is_logout_enabled (GSWindow *window) +{ + double elapsed; + + if (! window->priv->logout_enabled) + { + return FALSE; + } + + if (! window->priv->logout_command) + { + return FALSE; + } + + elapsed = g_timer_elapsed (window->priv->timer, NULL); + + if (window->priv->logout_timeout < (elapsed * 1000)) + { + return TRUE; + } + + return FALSE; +} + +static gboolean +is_user_switch_enabled (GSWindow *window) +{ + return window->priv->user_switch_enabled; +} + +static void +popup_dialog (GSWindow *window) +{ + gboolean result; + char *tmp; + GString *command; + + gs_debug ("Popping up dialog"); + + tmp = g_build_filename (LIBEXECDIR, "mate-screensaver-dialog", NULL); + command = g_string_new (tmp); + g_free (tmp); + + if (is_logout_enabled (window)) + { + command = g_string_append (command, " --enable-logout"); + g_string_append_printf (command, " --logout-command='%s'", window->priv->logout_command); + } + + if (window->priv->status_message) + { + char *quoted; + + quoted = g_shell_quote (window->priv->status_message); + g_string_append_printf (command, " --status-message=%s", quoted); + g_free (quoted); + } + + if (is_user_switch_enabled (window)) + { + command = g_string_append (command, " --enable-switch"); + } + + if (gs_debug_enabled ()) + { + command = g_string_append (command, " --verbose"); + } + + gtk_widget_hide (window->priv->drawing_area); + + gs_window_clear_to_background_pixmap (window); + + set_invisible_cursor (GTK_WIDGET (window)->window, FALSE); + + window->priv->dialog_quit_requested = FALSE; + window->priv->dialog_shake_in_progress = FALSE; + + result = spawn_on_window (window, + command->str, + &window->priv->lock_pid, + (GIOFunc)lock_command_watch, + window, + &window->priv->lock_watch_id); + if (! result) + { + gs_debug ("Could not start command: %s", command->str); + } + + g_string_free (command, TRUE); +} + +static gboolean +popup_dialog_idle (GSWindow *window) +{ + popup_dialog (window); + + window->priv->popup_dialog_idle_id = 0; + + return FALSE; +} + +void +gs_window_request_unlock (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Requesting unlock"); + + if (! GTK_WIDGET_VISIBLE (GTK_WIDGET (window))) + { + gs_debug ("Request unlock but window is not visible!"); + return; + } + + if (window->priv->lock_watch_id > 0) + { + return; + } + + if (! window->priv->lock_enabled) + { + add_emit_deactivated_idle (window); + + return; + } + + if (window->priv->popup_dialog_idle_id == 0) + { + add_popup_dialog_idle (window); + } + + window_set_dialog_up (window, TRUE); +} + +void +gs_window_cancel_unlock_request (GSWindow *window) +{ + /* FIXME: This is a bit of a hammer approach... + * Maybe we should send a delete-event to + * the plug? + */ + g_return_if_fail (GS_IS_WINDOW (window)); + + popdown_dialog (window); +} + +void +gs_window_set_lock_enabled (GSWindow *window, + gboolean lock_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->lock_enabled == lock_enabled) + { + return; + } + + window->priv->lock_enabled = lock_enabled; + g_object_notify (G_OBJECT (window), "lock-enabled"); +} + +void +gs_window_set_screen (GSWindow *window, + GdkScreen *screen) +{ + + g_return_if_fail (GS_IS_WINDOW (window)); + g_return_if_fail (GDK_IS_SCREEN (screen)); + + gtk_window_set_screen (GTK_WINDOW (window), screen); +} + +GdkScreen * +gs_window_get_screen (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return GTK_WINDOW (window)->screen; +} + +void +gs_window_set_keyboard_enabled (GSWindow *window, + gboolean enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->keyboard_enabled = enabled; +} + +void +gs_window_set_keyboard_command (GSWindow *window, + const char *command) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->keyboard_command); + + if (command != NULL) + { + window->priv->keyboard_command = g_strdup (command); + } + else + { + window->priv->keyboard_command = NULL; + } +} + +void +gs_window_set_logout_enabled (GSWindow *window, + gboolean logout_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->logout_enabled = logout_enabled; +} + +void +gs_window_set_user_switch_enabled (GSWindow *window, + gboolean user_switch_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->user_switch_enabled = user_switch_enabled; +} + +void +gs_window_set_logout_timeout (GSWindow *window, + glong logout_timeout) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (logout_timeout < 0) + { + window->priv->logout_timeout = 0; + } + else + { + window->priv->logout_timeout = logout_timeout; + } +} + +void +gs_window_set_logout_command (GSWindow *window, + const char *command) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->logout_command); + + if (command) + { + window->priv->logout_command = g_strdup (command); + } + else + { + window->priv->logout_command = NULL; + } +} + +void +gs_window_set_status_message (GSWindow *window, + const char *status_message) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->status_message); + window->priv->status_message = g_strdup (status_message); +} + +void +gs_window_set_monitor (GSWindow *window, + int monitor) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->monitor == monitor) + { + return; + } + + window->priv->monitor = monitor; + + gtk_widget_queue_resize (GTK_WIDGET (window)); + + g_object_notify (G_OBJECT (window), "monitor"); +} + +int +gs_window_get_monitor (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), -1); + + return window->priv->monitor; +} + +static void +gs_window_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSWindow *self; + + self = GS_WINDOW (object); + + switch (prop_id) + { + case PROP_LOCK_ENABLED: + gs_window_set_lock_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_ENABLED: + gs_window_set_keyboard_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_COMMAND: + gs_window_set_keyboard_command (self, g_value_get_string (value)); + break; + case PROP_LOGOUT_ENABLED: + gs_window_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_window_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_window_set_status_message (self, g_value_get_string (value)); + break; + case PROP_LOGOUT_TIMEOUT: + gs_window_set_logout_timeout (self, g_value_get_long (value)); + break; + case PROP_MONITOR: + gs_window_set_monitor (self, g_value_get_int (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_window_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSWindow *self; + + self = GS_WINDOW (object); + + switch (prop_id) + { + case PROP_LOCK_ENABLED: + g_value_set_boolean (value, self->priv->lock_enabled); + break; + case PROP_KEYBOARD_ENABLED: + g_value_set_boolean (value, self->priv->keyboard_enabled); + break; + case PROP_KEYBOARD_COMMAND: + g_value_set_string (value, self->priv->keyboard_command); + break; + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + case PROP_LOGOUT_TIMEOUT: + g_value_set_long (value, self->priv->logout_timeout); + break; + case PROP_MONITOR: + g_value_set_int (value, self->priv->monitor); + break; + case PROP_OBSCURED: + g_value_set_boolean (value, self->priv->obscured); + break; + case PROP_DIALOG_UP: + g_value_set_boolean (value, self->priv->dialog_up); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +queue_key_event (GSWindow *window, + GdkEventKey *event) +{ + /* Eat the first return, enter, escape, or space */ + if (window->priv->key_events == NULL + && (event->keyval == GDK_Return + || event->keyval == GDK_KP_Enter + || event->keyval == GDK_Escape + || event->keyval == GDK_space)) + { + return; + } + + /* Only cache MAX_QUEUED_EVENTS key events. If there are any more than this then + something is wrong */ + /* Don't queue keys that may cause focus navigation in the dialog */ + if (g_list_length (window->priv->key_events) < MAX_QUEUED_EVENTS + && event->keyval != GDK_Tab + && event->keyval != GDK_Up + && event->keyval != GDK_Down) + { + window->priv->key_events = g_list_prepend (window->priv->key_events, + gdk_event_copy ((GdkEvent *)event)); + } +} + +static gboolean +maybe_handle_activity (GSWindow *window) +{ + gboolean handled; + + handled = FALSE; + + /* if we already have a socket then don't bother */ + if (! window->priv->lock_socket + && GTK_WIDGET_IS_SENSITIVE (GTK_WIDGET (window))) + { + g_signal_emit (window, signals [ACTIVITY], 0, &handled); + } + + return handled; +} + +static gboolean +gs_window_real_key_press_event (GtkWidget *widget, + GdkEventKey *event) +{ + /*g_message ("KEY PRESS state: %u keyval %u", event->state, event->keyval);*/ + + /* Ignore brightness keys */ + if (event->hardware_keycode == 101 || event->hardware_keycode == 212) + { + gs_debug ("Ignoring brightness keys"); + return TRUE; + } + + maybe_handle_activity (GS_WINDOW (widget)); + + queue_key_event (GS_WINDOW (widget), event); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->key_press_event) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->key_press_event (widget, event); + } + + return TRUE; +} + +static gboolean +gs_window_real_motion_notify_event (GtkWidget *widget, + GdkEventMotion *event) +{ + GSWindow *window; + gdouble distance; + gdouble min_distance; + gdouble min_percentage = 0.1; + GdkScreen *screen; + + window = GS_WINDOW (widget); + + screen = gs_window_get_screen (window); + min_distance = gdk_screen_get_width (screen) * min_percentage; + + /* if the last position was not set then don't detect motion */ + if (window->priv->last_x < 0 || window->priv->last_y < 0) + { + window->priv->last_x = event->x; + window->priv->last_y = event->y; + + return FALSE; + } + + /* just an approximate distance */ + distance = MAX (ABS (window->priv->last_x - event->x), + ABS (window->priv->last_y - event->y)); + + if (distance > min_distance) + { + maybe_handle_activity (window); + + window->priv->last_x = -1; + window->priv->last_y = -1; + } + + return FALSE; +} + +static gboolean +gs_window_real_button_press_event (GtkWidget *widget, + GdkEventButton *event) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + maybe_handle_activity (window); + + return FALSE; +} + +static gboolean +gs_window_real_scroll_event (GtkWidget *widget, + GdkEventScroll *event) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + maybe_handle_activity (window); + + return FALSE; +} + +static void +gs_window_real_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GSWindow *window; + GtkBin *bin; + GdkRectangle old_geometry; + int position_changed = FALSE; + int size_changed = FALSE; + + window = GS_WINDOW (widget); + bin = GTK_BIN (widget); + + if (bin->child && GTK_WIDGET_VISIBLE (bin->child)) + { + gtk_widget_size_request (bin->child, requisition); + } + + old_geometry = window->priv->geometry; + + update_geometry (window); + + requisition->width = window->priv->geometry.width; + requisition->height = window->priv->geometry.height; + + if (! GTK_WIDGET_REALIZED (widget)) + { + return; + } + + if (old_geometry.width != window->priv->geometry.width || + old_geometry.height != window->priv->geometry.height) + { + size_changed = TRUE; + } + + if (old_geometry.x != window->priv->geometry.x || + old_geometry.y != window->priv->geometry.y) + { + position_changed = TRUE; + } + + gs_window_move_resize_window (window, position_changed, size_changed); +} + +static gboolean +gs_window_real_grab_broken (GtkWidget *widget, + GdkEventGrabBroken *event) +{ + if (event->grab_window != NULL) + { + gs_debug ("Grab broken on window %X %s, new grab on window %X", + (guint32) GDK_WINDOW_XID (event->window), + event->keyboard ? "keyboard" : "pointer", + (guint32) GDK_WINDOW_XID (event->grab_window)); + } + else + { + gs_debug ("Grab broken on window %X %s, new grab is outside application", + (guint32) GDK_WINDOW_XID (event->window), + event->keyboard ? "keyboard" : "pointer"); + } + + return FALSE; +} + +gboolean +gs_window_is_obscured (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + return window->priv->obscured; +} + +gboolean +gs_window_is_dialog_up (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + return window->priv->dialog_up; +} + +static void +window_set_obscured (GSWindow *window, + gboolean obscured) +{ + if (window->priv->obscured == obscured) + { + return; + } + + window->priv->obscured = obscured; + g_object_notify (G_OBJECT (window), "obscured"); +} + +static gboolean +gs_window_real_visibility_notify_event (GtkWidget *widget, + GdkEventVisibility *event) +{ + switch (event->state) + { + case GDK_VISIBILITY_FULLY_OBSCURED: + window_set_obscured (GS_WINDOW (widget), TRUE); + break; + case GDK_VISIBILITY_PARTIAL: + break; + case GDK_VISIBILITY_UNOBSCURED: + window_set_obscured (GS_WINDOW (widget), FALSE); + break; + default: + break; + } + + return FALSE; +} + +static void +gs_window_class_init (GSWindowClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->finalize = gs_window_finalize; + object_class->get_property = gs_window_get_property; + object_class->set_property = gs_window_set_property; + + widget_class->show = gs_window_real_show; + widget_class->hide = gs_window_real_hide; + widget_class->realize = gs_window_real_realize; + widget_class->unrealize = gs_window_real_unrealize; + widget_class->key_press_event = gs_window_real_key_press_event; + widget_class->motion_notify_event = gs_window_real_motion_notify_event; + widget_class->button_press_event = gs_window_real_button_press_event; + widget_class->scroll_event = gs_window_real_scroll_event; + widget_class->size_request = gs_window_real_size_request; + widget_class->grab_broken_event = gs_window_real_grab_broken; + widget_class->visibility_notify_event = gs_window_real_visibility_notify_event; + + g_type_class_add_private (klass, sizeof (GSWindowPrivate)); + + signals [ACTIVITY] = + g_signal_new ("activity", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWindowClass, activity), + NULL, + NULL, + gs_marshal_BOOLEAN__VOID, + G_TYPE_BOOLEAN, + 0); + signals [DEACTIVATED] = + g_signal_new ("deactivated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWindowClass, deactivated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_object_class_install_property (object_class, + PROP_OBSCURED, + g_param_spec_boolean ("obscured", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_DIALOG_UP, + g_param_spec_boolean ("dialog-up", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_LOCK_ENABLED, + g_param_spec_boolean ("lock-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_TIMEOUT, + g_param_spec_long ("logout-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_KEYBOARD_ENABLED, + g_param_spec_boolean ("keyboard-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_KEYBOARD_COMMAND, + g_param_spec_string ("keyboard-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_MONITOR, + g_param_spec_int ("monitor", + "Xinerama monitor", + "The monitor (in terms of Xinerama) which the window is on", + 0, + G_MAXINT, + 0, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + +} + +static void +create_info_bar (GSWindow *window) +{ + window->priv->info_bar = gtk_info_bar_new (); + gtk_widget_set_no_show_all (window->priv->info_bar, TRUE); + gtk_box_pack_end (GTK_BOX (window->priv->vbox), window->priv->info_bar, FALSE, FALSE, 0); +} + +static void +gs_window_init (GSWindow *window) +{ + window->priv = GS_WINDOW_GET_PRIVATE (window); + + window->priv->geometry.x = -1; + window->priv->geometry.y = -1; + window->priv->geometry.width = -1; + window->priv->geometry.height = -1; + + window->priv->last_x = -1; + window->priv->last_y = -1; + + gtk_window_set_decorated (GTK_WINDOW (window), FALSE); + + gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE); + gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE); + + gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); + + gtk_window_fullscreen (GTK_WINDOW (window)); + + gtk_widget_set_events (GTK_WIDGET (window), + gtk_widget_get_events (GTK_WIDGET (window)) + | GDK_POINTER_MOTION_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_KEY_PRESS_MASK + | GDK_KEY_RELEASE_MASK + | GDK_EXPOSURE_MASK + | GDK_VISIBILITY_NOTIFY_MASK + | GDK_ENTER_NOTIFY_MASK + | GDK_LEAVE_NOTIFY_MASK); + + window->priv->vbox = gtk_vbox_new (FALSE, 12); + gtk_widget_show (window->priv->vbox); + gtk_container_add (GTK_CONTAINER (window), window->priv->vbox); + + window->priv->drawing_area = gtk_drawing_area_new (); + gtk_widget_show (window->priv->drawing_area); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->drawing_area, TRUE, TRUE, 0); + create_info_bar (window); + + force_no_pixmap_background (window->priv->drawing_area); +} + +static void +remove_command_watches (GSWindow *window) +{ + if (window->priv->lock_watch_id != 0) + { + g_source_remove (window->priv->lock_watch_id); + window->priv->lock_watch_id = 0; + } + if (window->priv->keyboard_watch_id != 0) + { + g_source_remove (window->priv->keyboard_watch_id); + window->priv->keyboard_watch_id = 0; + } +} + +static void +gs_window_finalize (GObject *object) +{ + GSWindow *window; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_WINDOW (object)); + + window = GS_WINDOW (object); + + g_return_if_fail (window->priv != NULL); + + g_free (window->priv->logout_command); + g_free (window->priv->keyboard_command); + + if (window->priv->info_bar_timer_id > 0) + { + g_source_remove (window->priv->info_bar_timer_id); + } + + remove_watchdog_timer (window); + remove_popup_dialog_idle (window); + + if (window->priv->timer) + { + g_timer_destroy (window->priv->timer); + } + + remove_key_events (window); + + remove_command_watches (window); + + gs_window_dialog_finish (window); + + if (window->priv->background_pixmap) + { + g_object_unref (window->priv->background_pixmap); + } + + G_OBJECT_CLASS (gs_window_parent_class)->finalize (object); +} + +GSWindow * +gs_window_new (GdkScreen *screen, + int monitor, + gboolean lock_enabled) +{ + GObject *result; + + result = g_object_new (GS_TYPE_WINDOW, + "type", GTK_WINDOW_POPUP, + "screen", screen, + "monitor", monitor, + "lock-enabled", lock_enabled, + NULL); + + return GS_WINDOW (result); +} diff --git a/src/gs-window-x11.c.orig b/src/gs-window-x11.c.orig new file mode 100644 index 0000000..f7c3c70 --- /dev/null +++ b/src/gs-window-x11.c.orig @@ -0,0 +1,2647 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2008 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-window.h" +#include "gs-marshal.h" +#include "subprocs.h" +#include "gs-debug.h" + +#ifdef HAVE_SHAPE_EXT +#include +#endif + +static void gs_window_class_init (GSWindowClass *klass); +static void gs_window_init (GSWindow *window); +static void gs_window_finalize (GObject *object); + +static gboolean popup_dialog_idle (GSWindow *window); +static void gs_window_dialog_finish (GSWindow *window); +static void remove_command_watches (GSWindow *window); + +enum +{ + DIALOG_RESPONSE_CANCEL, + DIALOG_RESPONSE_OK +}; + +#define MAX_QUEUED_EVENTS 16 +#define INFO_BAR_SECONDS 30 + +#define GS_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GS_TYPE_WINDOW, GSWindowPrivate)) + +struct GSWindowPrivate +{ + int monitor; + + GdkRectangle geometry; + guint obscured : 1; + guint dialog_up : 1; + + guint lock_enabled : 1; + guint user_switch_enabled : 1; + guint logout_enabled : 1; + guint keyboard_enabled : 1; + + guint64 logout_timeout; + char *logout_command; + char *keyboard_command; + char *status_message; + + GtkWidget *vbox; + GtkWidget *drawing_area; + GtkWidget *lock_box; + GtkWidget *lock_socket; + GtkWidget *keyboard_socket; + GtkWidget *info_bar; + GtkWidget *info_content; + + GdkPixmap *background_pixmap; + + guint popup_dialog_idle_id; + + guint dialog_map_signal_id; + guint dialog_unmap_signal_id; + guint dialog_response_signal_id; + + guint watchdog_timer_id; + guint info_bar_timer_id; + + gint lock_pid; + gint lock_watch_id; + gint dialog_response; + gboolean dialog_quit_requested; + gboolean dialog_shake_in_progress; + + gint keyboard_pid; + gint keyboard_watch_id; + + GList *key_events; + + gdouble last_x; + gdouble last_y; + + GTimer *timer; + +#ifdef HAVE_SHAPE_EXT + int shape_event_base; +#endif +}; + +enum +{ + ACTIVITY, + DEACTIVATED, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_OBSCURED, + PROP_DIALOG_UP, + PROP_LOCK_ENABLED, + PROP_LOGOUT_ENABLED, + PROP_KEYBOARD_ENABLED, + PROP_KEYBOARD_COMMAND, + PROP_LOGOUT_COMMAND, + PROP_LOGOUT_TIMEOUT, + PROP_MONITOR, + PROP_STATUS_MESSAGE +}; + +static guint signals [LAST_SIGNAL] = { 0, }; + +G_DEFINE_TYPE (GSWindow, gs_window, GTK_TYPE_WINDOW) + +static void +set_invisible_cursor (GdkWindow *window, + gboolean invisible) +{ + GdkBitmap *empty_bitmap; + GdkCursor *cursor = NULL; + GdkColor useless; + char invisible_cursor_bits [] = { 0x0 }; + + if (invisible) + { + useless.red = useless.green = useless.blue = 0; + useless.pixel = 0; + + empty_bitmap = gdk_bitmap_create_from_data (window, + invisible_cursor_bits, + 1, 1); + + cursor = gdk_cursor_new_from_pixmap (empty_bitmap, + empty_bitmap, + &useless, + &useless, 0, 0); + + g_object_unref (empty_bitmap); + } + + gdk_window_set_cursor (window, cursor); + + if (cursor) + { + gdk_cursor_unref (cursor); + } +} + +/* derived from tomboy */ +static void +gs_window_override_user_time (GSWindow *window) +{ + guint32 ev_time = gtk_get_current_event_time (); + + if (ev_time == 0) + { + gint ev_mask = gtk_widget_get_events (GTK_WIDGET (window)); + if (!(ev_mask & GDK_PROPERTY_CHANGE_MASK)) + { + gtk_widget_add_events (GTK_WIDGET (window), + GDK_PROPERTY_CHANGE_MASK); + } + + /* + * NOTE: Last resort for D-BUS or other non-interactive + * openings. Causes roundtrip to server. Lame. + */ + ev_time = gdk_x11_get_server_time (GTK_WIDGET (window)->window); + } + + gdk_x11_window_set_user_time (GTK_WIDGET (window)->window, ev_time); +} + +static void +force_no_pixmap_background (GtkWidget *widget) +{ + static gboolean first_time = TRUE; + + if (first_time) + { + gtk_rc_parse_string ("\n" + " style \"gs-theme-engine-style\"\n" + " {\n" + " bg_pixmap[NORMAL] = \"\"\n" + " bg_pixmap[INSENSITIVE] = \"\"\n" + " bg_pixmap[ACTIVE] = \"\"\n" + " bg_pixmap[PRELIGHT] = \"\"\n" + " bg[NORMAL] = { 0.0, 0.0, 0.0 }\n" + " bg[INSENSITIVE] = { 0.0, 0.0, 0.0 }\n" + " bg[ACTIVE] = { 0.0, 0.0, 0.0 }\n" + " bg[PRELIGHT] = { 0.0, 0.0, 0.0 }\n" + " }\n" + " widget \"gs-window-drawing-area*\" style : highest \"gs-theme-engine-style\"\n" + "\n"); + first_time = FALSE; + } + + gtk_widget_set_name (widget, "gs-window-drawing-area"); +} + +static void +clear_children (Window window) +{ + Window root; + Window parent; + Window *children; + unsigned int n_children; + int status; + + children = NULL; + status = XQueryTree (GDK_DISPLAY (), window, &root, &parent, &children, &n_children); + + if (status == 0) + { + if (children) + { + XFree (children); + } + return; + } + + if (children) + { + while (n_children) + { + Window child; + + child = children [--n_children]; + + XClearWindow (GDK_DISPLAY (), child); + clear_children (child); + } + + XFree (children); + } +} + +static void +widget_clear_all_children (GtkWidget *widget) +{ + GdkWindow *w; + + gs_debug ("Clearing all child windows"); + + gdk_error_trap_push (); + + w = widget->window; + + clear_children (GDK_WINDOW_XID (w)); + + gdk_display_sync (gtk_widget_get_display (widget)); + gdk_error_trap_pop (); +} + +void +gs_window_set_background_pixmap (GSWindow *window, + GdkPixmap *pixmap) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->background_pixmap != NULL) + { + g_object_unref (window->priv->background_pixmap); + } + + if (pixmap != NULL) + { + window->priv->background_pixmap = g_object_ref (pixmap); + gdk_window_set_back_pixmap (GTK_WIDGET (window)->window, + pixmap, + FALSE); + } +} + +static void +gs_window_clear_to_background_pixmap (GSWindow *window) +{ + GtkStateType state; + GtkStyle *style; + + g_return_if_fail (GS_IS_WINDOW (window)); + + if (! GTK_WIDGET_VISIBLE (GTK_WIDGET (window))) + { + return; + } + + if (window->priv->background_pixmap == NULL) + { + /* don't allow null pixmaps */ + return; + } + + gs_debug ("Clearing window to background pixmap"); + + style = gtk_style_copy (GTK_WIDGET (window)->style); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (GTK_WIDGET (window)->style->bg_pixmap)) + { + + if (style->bg_pixmap[state] != NULL) + { + g_object_unref (style->bg_pixmap[state]); + } + + style->bg_pixmap[state] = g_object_ref (window->priv->background_pixmap); + state++; + } + + gtk_widget_set_style (GTK_WIDGET (window), style); + g_object_unref (style); + + if (window->priv->background_pixmap != NULL) + { + gdk_window_set_back_pixmap (GTK_WIDGET (window)->window, + window->priv->background_pixmap, + FALSE); + } + + gdk_window_clear (GTK_WIDGET (window)->window); + + gdk_flush (); +} + +static void +clear_widget (GtkWidget *widget) +{ + GdkColor color = { 0, 0x0000, 0x0000, 0x0000 }; + GdkColormap *colormap; + GtkStateType state; + GtkStyle *style; + + if (! GTK_WIDGET_VISIBLE (widget)) + { + return; + } + + gs_debug ("Clearing widget"); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg)) + { + gtk_widget_modify_bg (widget, state, &color); + state++; + } + + style = gtk_style_copy (widget->style); + + state = (GtkStateType) 0; + while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg_pixmap)) + { + + if (style->bg_pixmap[state] != NULL) + { + g_object_unref (style->bg_pixmap[state]); + } + + style->bg_pixmap[state] = NULL; + state++; + } + + colormap = gdk_drawable_get_colormap (widget->window); + gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE); + gdk_window_set_background (widget->window, &color); + + gtk_widget_set_style (widget, style); + g_object_unref (style); + + gdk_window_clear (widget->window); + + /* If a screensaver theme adds child windows we need to clear them too */ + widget_clear_all_children (widget); + + gdk_flush (); +} + +void +gs_window_clear (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + clear_widget (GTK_WIDGET (window)); + clear_widget (window->priv->drawing_area); +} + +static GdkRegion * +get_outside_region (GSWindow *window) +{ + int i; + GdkRegion *region; + + region = gdk_region_new (); + for (i = 0; i < window->priv->monitor; i++) + { + GdkRectangle geometry; + + gdk_screen_get_monitor_geometry (GTK_WINDOW (window)->screen, + i, &geometry); + gdk_region_union_with_rect (region, &geometry); + } + + return region; +} + +static void +update_geometry (GSWindow *window) +{ + GdkRectangle geometry; + GdkRegion *outside_region; + GdkRegion *monitor_region; + + outside_region = get_outside_region (window); + + gdk_screen_get_monitor_geometry (GTK_WINDOW (window)->screen, + window->priv->monitor, + &geometry); + gs_debug ("got geometry for monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + geometry.x, + geometry.y, + geometry.width, + geometry.height); + monitor_region = gdk_region_rectangle (&geometry); + gdk_region_subtract (monitor_region, outside_region); + gdk_region_destroy (outside_region); + + gdk_region_get_clipbox (monitor_region, &geometry); + gdk_region_destroy (monitor_region); + + gs_debug ("using geometry for monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + geometry.x, + geometry.y, + geometry.width, + geometry.height); + + window->priv->geometry.x = geometry.x; + window->priv->geometry.y = geometry.y; + window->priv->geometry.width = geometry.width; + window->priv->geometry.height = geometry.height; +} + +static void +screen_size_changed (GdkScreen *screen, + GSWindow *window) +{ + gs_debug ("Got screen size changed signal"); + gtk_widget_queue_resize (GTK_WIDGET (window)); +} + +/* copied from panel-toplevel.c */ +static void +gs_window_move_resize_window (GSWindow *window, + gboolean move, + gboolean resize) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (window); + + g_assert (GTK_WIDGET_REALIZED (widget)); + + gs_debug ("Move and/or resize window on monitor %d: x=%d y=%d w=%d h=%d", + window->priv->monitor, + window->priv->geometry.x, + window->priv->geometry.y, + window->priv->geometry.width, + window->priv->geometry.height); + + if (move && resize) + { + gdk_window_move_resize (widget->window, + window->priv->geometry.x, + window->priv->geometry.y, + window->priv->geometry.width, + window->priv->geometry.height); + } + else if (move) + { + gdk_window_move (widget->window, + window->priv->geometry.x, + window->priv->geometry.y); + } + else if (resize) + { + gdk_window_resize (widget->window, + window->priv->geometry.width, + window->priv->geometry.height); + } +} + +static void +gs_window_real_unrealize (GtkWidget *widget) +{ + g_signal_handlers_disconnect_by_func (gtk_window_get_screen (GTK_WINDOW (widget)), + screen_size_changed, + widget); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->unrealize) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->unrealize (widget); + } +} + +/* copied from gdk */ +extern char **environ; + +static gchar ** +spawn_make_environment_for_screen (GdkScreen *screen, + gchar **envp) +{ + gchar **retval = NULL; + gchar *display_name; + gint display_index = -1; + gint i, env_len; + + g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL); + + if (envp == NULL) + envp = environ; + + for (env_len = 0; envp[env_len]; env_len++) + if (strncmp (envp[env_len], "DISPLAY", strlen ("DISPLAY")) == 0) + display_index = env_len; + + retval = g_new (char *, env_len + 1); + retval[env_len] = NULL; + + display_name = gdk_screen_make_display_name (screen); + + for (i = 0; i < env_len; i++) + if (i == display_index) + retval[i] = g_strconcat ("DISPLAY=", display_name, NULL); + else + retval[i] = g_strdup (envp[i]); + + g_assert (i == env_len); + + g_free (display_name); + + return retval; +} + +static gboolean +spawn_command_line_on_screen_sync (GdkScreen *screen, + const gchar *command_line, + char **standard_output, + char **standard_error, + int *exit_status, + GError **error) +{ + char **argv = NULL; + char **envp = NULL; + gboolean retval; + + g_return_val_if_fail (command_line != NULL, FALSE); + + if (! g_shell_parse_argv (command_line, NULL, &argv, error)) + { + return FALSE; + } + + envp = spawn_make_environment_for_screen (screen, NULL); + + retval = g_spawn_sync (NULL, + argv, + envp, + G_SPAWN_SEARCH_PATH, + NULL, + NULL, + standard_output, + standard_error, + exit_status, + error); + + g_strfreev (argv); + g_strfreev (envp); + + return retval; +} + +static GdkVisual * +get_best_visual_for_screen (GdkScreen *screen) +{ + 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; + std_output = NULL; + res = spawn_command_line_on_screen_sync (screen, + command, + &std_output, + NULL, + &exit_status, + &error); + if (! res) + { + gs_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); + + gs_debug ("Found best GL visual for screen %d: 0x%x", + gdk_screen_get_number (screen), + (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_for_screen (screen); + + 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 void +gs_window_real_realize (GtkWidget *widget) +{ + widget_set_best_colormap (widget); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->realize) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->realize (widget); + } + + gs_window_override_user_time (GS_WINDOW (widget)); + + gs_window_move_resize_window (GS_WINDOW (widget), TRUE, TRUE); + + g_signal_connect (gtk_window_get_screen (GTK_WINDOW (widget)), + "size_changed", + G_CALLBACK (screen_size_changed), + widget); +} + +/* every so often we should raise the window in case + another window has somehow gotten on top */ +static gboolean +watchdog_timer (GSWindow *window) +{ + GtkWidget *widget = GTK_WIDGET (window); + + gdk_window_focus (widget->window, GDK_CURRENT_TIME); + + return TRUE; +} + +static void +remove_watchdog_timer (GSWindow *window) +{ + if (window->priv->watchdog_timer_id != 0) + { + g_source_remove (window->priv->watchdog_timer_id); + window->priv->watchdog_timer_id = 0; + } +} + +static void +add_watchdog_timer (GSWindow *window, + glong timeout) +{ + window->priv->watchdog_timer_id = g_timeout_add (timeout, + (GSourceFunc)watchdog_timer, + window); +} + +static void +remove_popup_dialog_idle (GSWindow *window) +{ + if (window->priv->popup_dialog_idle_id != 0) + { + g_source_remove (window->priv->popup_dialog_idle_id); + window->priv->popup_dialog_idle_id = 0; + } +} + +static void +add_popup_dialog_idle (GSWindow *window) +{ + window->priv->popup_dialog_idle_id = g_idle_add ((GSourceFunc)popup_dialog_idle, window); +} + +static gboolean +emit_deactivated_idle (GSWindow *window) +{ + g_signal_emit (window, signals [DEACTIVATED], 0); + + return FALSE; +} + +static void +add_emit_deactivated_idle (GSWindow *window) +{ + g_idle_add ((GSourceFunc)emit_deactivated_idle, window); +} + +static void +gs_window_raise (GSWindow *window) +{ + GdkWindow *win; + + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Raising screensaver window"); + + win = GTK_WIDGET (window)->window; + + gdk_window_raise (win); +} + +static gboolean +x11_window_is_ours (Window window) +{ + GdkWindow *gwindow; + gboolean ret; + + ret = FALSE; + + gwindow = gdk_window_lookup (window); + if (gwindow && (window != GDK_ROOT_WINDOW ())) + { + ret = TRUE; + } + + return ret; +} + +#ifdef HAVE_SHAPE_EXT +static void +unshape_window (GSWindow *window) +{ + gdk_window_shape_combine_region (GTK_WIDGET (window)->window, + NULL, + 0, + 0); +} +#endif + +static void +gs_window_xevent (GSWindow *window, + GdkXEvent *xevent) +{ + XEvent *ev; + + ev = xevent; + + /* MapNotify is used to tell us when new windows are mapped. + ConfigureNofify is used to tell us when windows are raised. */ + switch (ev->xany.type) + { + case MapNotify: + { + XMapEvent *xme = &ev->xmap; + + if (! x11_window_is_ours (xme->window)) + { + gs_window_raise (window); + } + else + { + gs_debug ("not raising our windows"); + } + + break; + } + case ConfigureNotify: + { + XConfigureEvent *xce = &ev->xconfigure; + + if (! x11_window_is_ours (xce->window)) + { + gs_window_raise (window); + } + else + { + gs_debug ("not raising our windows"); + } + + break; + } + default: + /* extension events */ +#ifdef HAVE_SHAPE_EXT + if (ev->xany.type == (window->priv->shape_event_base + ShapeNotify)) + { + /*XShapeEvent *xse = (XShapeEvent *) ev;*/ + unshape_window (window); + gs_debug ("Window was reshaped!"); + } +#endif + + break; + } + +} + +static GdkFilterReturn +xevent_filter (GdkXEvent *xevent, + GdkEvent *event, + GSWindow *window) +{ + gs_window_xevent (window, xevent); + + return GDK_FILTER_CONTINUE; +} + +static void +select_popup_events (void) +{ + XWindowAttributes attr; + unsigned long events; + + gdk_error_trap_push (); + + memset (&attr, 0, sizeof (attr)); + XGetWindowAttributes (GDK_DISPLAY (), GDK_ROOT_WINDOW (), &attr); + + events = SubstructureNotifyMask | attr.your_event_mask; + XSelectInput (GDK_DISPLAY (), GDK_ROOT_WINDOW (), events); + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +} + +static void +window_select_shape_events (GSWindow *window) +{ +#ifdef HAVE_SHAPE_EXT + unsigned long events; + int shape_error_base; + + gdk_error_trap_push (); + + if (XShapeQueryExtension (GDK_DISPLAY (), &window->priv->shape_event_base, &shape_error_base)) + { + events = ShapeNotifyMask; + XShapeSelectInput (GDK_DISPLAY (), GDK_WINDOW_XID (GTK_WIDGET (window)->window), events); + } + + gdk_display_sync (gdk_display_get_default ()); + gdk_error_trap_pop (); +#endif +} + +static void +gs_window_real_show (GtkWidget *widget) +{ + GSWindow *window; + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->show) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->show (widget); + } + + gs_window_clear (GS_WINDOW (widget)); + + set_invisible_cursor (widget->window, TRUE); + + window = GS_WINDOW (widget); + if (window->priv->timer) + { + g_timer_destroy (window->priv->timer); + } + window->priv->timer = g_timer_new (); + + remove_watchdog_timer (window); + add_watchdog_timer (window, 30000); + + select_popup_events (); + window_select_shape_events (window); + gdk_window_add_filter (NULL, (GdkFilterFunc)xevent_filter, window); +} + +static void +set_info_text_and_icon (GSWindow *window, + const char *icon_stock_id, + const char *primary_text, + const char *secondary_text) +{ + GtkWidget *content_area; + GtkWidget *hbox_content; + GtkWidget *image; + GtkWidget *vbox; + gchar *primary_markup; + gchar *secondary_markup; + GtkWidget *primary_label; + GtkWidget *secondary_label; + + hbox_content = gtk_hbox_new (FALSE, 8); + gtk_widget_show (hbox_content); + + image = gtk_image_new_from_stock (icon_stock_id, GTK_ICON_SIZE_DIALOG); + gtk_widget_show (image); + gtk_box_pack_start (GTK_BOX (hbox_content), image, FALSE, FALSE, 0); + gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_widget_show (vbox); + gtk_box_pack_start (GTK_BOX (hbox_content), vbox, FALSE, FALSE, 0); + + primary_markup = g_strdup_printf ("%s", primary_text); + primary_label = gtk_label_new (primary_markup); + g_free (primary_markup); + gtk_widget_show (primary_label); + gtk_box_pack_start (GTK_BOX (vbox), primary_label, TRUE, TRUE, 0); + gtk_label_set_use_markup (GTK_LABEL (primary_label), TRUE); + gtk_label_set_line_wrap (GTK_LABEL (primary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (primary_label), 0, 0.5); + + if (secondary_text != NULL) + { + secondary_markup = g_strdup_printf ("%s", + secondary_text); + secondary_label = gtk_label_new (secondary_markup); + g_free (secondary_markup); + gtk_widget_show (secondary_label); + gtk_box_pack_start (GTK_BOX (vbox), secondary_label, TRUE, TRUE, 0); + gtk_label_set_use_markup (GTK_LABEL (secondary_label), TRUE); + gtk_label_set_line_wrap (GTK_LABEL (secondary_label), TRUE); + gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5); + } + + /* remove old content */ + content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (window->priv->info_bar)); + if (window->priv->info_content != NULL) + { + gtk_container_remove (GTK_CONTAINER (content_area), window->priv->info_content); + } + gtk_box_pack_start (GTK_BOX (content_area), + hbox_content, + TRUE, FALSE, 0); + window->priv->info_content = hbox_content; +} + +static gboolean +info_bar_timeout (GSWindow *window) +{ + window->priv->info_bar_timer_id = 0; + gtk_widget_hide (window->priv->info_bar); + return FALSE; +} + +void +gs_window_show_message (GSWindow *window, + const char *summary, + const char *body, + const char *icon) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + set_info_text_and_icon (window, + icon, + summary, + body); + gtk_widget_show (window->priv->info_bar); + + if (window->priv->info_bar_timer_id > 0) + { + g_source_remove (window->priv->info_bar_timer_id); + } + + window->priv->info_bar_timer_id = g_timeout_add_seconds (INFO_BAR_SECONDS, + (GSourceFunc)info_bar_timeout, + window); +} + +void +gs_window_show (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gtk_widget_show (GTK_WIDGET (window)); +} + +static void +gs_window_real_hide (GtkWidget *widget) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + + gdk_window_remove_filter (NULL, (GdkFilterFunc)xevent_filter, window); + + remove_watchdog_timer (window); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->hide) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->hide (widget); + } +} + +void +gs_window_destroy (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_window_cancel_unlock_request (window); + + gtk_widget_destroy (GTK_WIDGET (window)); +} + +GdkWindow * +gs_window_get_gdk_window (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return GTK_WIDGET (window)->window; +} + +GtkWidget * +gs_window_get_drawing_area (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return window->priv->drawing_area; +} + +/* just for debugging */ +static gboolean +error_watch (GIOChannel *source, + GIOCondition condition, + gpointer data) +{ + gboolean finished = FALSE; + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + gs_debug ("command error output: %s", line); + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +spawn_on_window (GSWindow *window, + char *command, + int *pid, + GIOFunc watch_func, + gpointer user_data, + gint *watch_id) +{ + int argc; + char **argv; + GError *error; + gboolean result; + GIOChannel *channel; + int standard_output; + int standard_error; + int child_pid; + int id; + + error = NULL; + if (! g_shell_parse_argv (command, &argc, &argv, &error)) + { + gs_debug ("Could not parse command: %s", error->message); + g_error_free (error); + return FALSE; + } + + error = NULL; + result = gdk_spawn_on_screen_with_pipes (GTK_WINDOW (window)->screen, + NULL, + argv, + NULL, + G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH, + NULL, + NULL, + &child_pid, + NULL, + &standard_output, + &standard_error, + &error); + + if (! result) + { + gs_debug ("Could not start command '%s': %s", command, error->message); + g_error_free (error); + g_strfreev (argv); + return FALSE; + } + + if (pid != NULL) + { + *pid = child_pid; + } + else + { + g_spawn_close_pid (child_pid); + } + + /* output channel */ + channel = g_io_channel_unix_new (standard_output); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + watch_func, + user_data); + if (watch_id != NULL) + { + *watch_id = id; + } + g_io_channel_unref (channel); + + /* error channel */ + channel = g_io_channel_unix_new (standard_error); + g_io_channel_set_close_on_unref (channel, TRUE); + g_io_channel_set_flags (channel, + g_io_channel_get_flags (channel) | G_IO_FLAG_NONBLOCK, + NULL); + id = g_io_add_watch (channel, + G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + error_watch, + NULL); + g_io_channel_unref (channel); + + g_strfreev (argv); + + return result; +} + +static void +lock_plug_added (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_show (widget); +} + +static gboolean +lock_plug_removed (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_hide (widget); + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->lock_box)); + window->priv->lock_box = NULL; + + return TRUE; +} + +static void +keyboard_plug_added (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_show (widget); +} + +static gboolean +keyboard_plug_removed (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_hide (widget); + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->keyboard_socket)); + + return TRUE; +} + +static void +keyboard_socket_destroyed (GtkWidget *widget, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (widget, keyboard_socket_destroyed, window); + g_signal_handlers_disconnect_by_func (widget, keyboard_plug_added, window); + g_signal_handlers_disconnect_by_func (widget, keyboard_plug_removed, window); + + window->priv->keyboard_socket = NULL; +} + +static void +forward_key_events (GSWindow *window) +{ + window->priv->key_events = g_list_reverse (window->priv->key_events); + + while (window->priv->key_events != NULL) + { + GdkEventKey *event = window->priv->key_events->data; + + gtk_window_propagate_key_event (GTK_WINDOW (window), event); + + gdk_event_free ((GdkEvent *)event); + window->priv->key_events = g_list_delete_link (window->priv->key_events, + window->priv->key_events); + } +} + +static void +remove_key_events (GSWindow *window) +{ + window->priv->key_events = g_list_reverse (window->priv->key_events); + + while (window->priv->key_events) + { + GdkEventKey *event = window->priv->key_events->data; + + gdk_event_free ((GdkEvent *)event); + window->priv->key_events = g_list_delete_link (window->priv->key_events, + window->priv->key_events); + } +} + +static void +lock_socket_show (GtkWidget *widget, + GSWindow *window) +{ + gtk_widget_child_focus (window->priv->lock_socket, GTK_DIR_TAB_FORWARD); + + /* send queued events to the dialog */ + forward_key_events (window); +} + +static void +lock_socket_destroyed (GtkWidget *widget, + GSWindow *window) +{ + g_signal_handlers_disconnect_by_func (widget, lock_socket_show, window); + g_signal_handlers_disconnect_by_func (widget, lock_socket_destroyed, window); + g_signal_handlers_disconnect_by_func (widget, lock_plug_added, window); + g_signal_handlers_disconnect_by_func (widget, lock_plug_removed, window); + + window->priv->lock_socket = NULL; +} + +static void +create_keyboard_socket (GSWindow *window, + guint32 id) +{ + int height; + + height = (gdk_screen_get_height (gtk_widget_get_screen (GTK_WIDGET (window)))) / 4; + + window->priv->keyboard_socket = gtk_socket_new (); + gtk_widget_set_size_request (window->priv->keyboard_socket, -1, height); + + g_signal_connect (window->priv->keyboard_socket, "destroy", + G_CALLBACK (keyboard_socket_destroyed), window); + g_signal_connect (window->priv->keyboard_socket, "plug_added", + G_CALLBACK (keyboard_plug_added), window); + g_signal_connect (window->priv->keyboard_socket, "plug_removed", + G_CALLBACK (keyboard_plug_removed), window); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->keyboard_socket, FALSE, FALSE, 0); + gtk_socket_add_id (GTK_SOCKET (window->priv->keyboard_socket), id); +} + +/* adapted from gspawn.c */ +static int +wait_on_child (int pid) +{ + int status; + +wait_again: + if (waitpid (pid, &status, 0) < 0) + { + if (errno == EINTR) + { + goto wait_again; + } + else if (errno == ECHILD) + { + ; /* do nothing, child already reaped */ + } + else + { + gs_debug ("waitpid () should not fail in 'GSWindow'"); + } + } + + return status; +} + +static void +kill_keyboard_command (GSWindow *window) +{ + if (window->priv->keyboard_pid > 0) + { + signal_pid (window->priv->keyboard_pid, SIGTERM); + } +} + +static void +kill_dialog_command (GSWindow *window) +{ + /* If a dialog is up we need to signal it + and wait on it */ + if (window->priv->lock_pid > 0) + { + signal_pid (window->priv->lock_pid, SIGTERM); + } +} + +static void +keyboard_command_finish (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + /* send a signal just in case */ + kill_keyboard_command (window); + + gs_debug ("Keyboard finished"); + + if (window->priv->keyboard_pid > 0) + { + int exit_status; + + exit_status = wait_on_child (window->priv->keyboard_pid); + + g_spawn_close_pid (window->priv->keyboard_pid); + window->priv->keyboard_pid = 0; + } +} + +static gboolean +keyboard_command_watch (GIOChannel *source, + GIOCondition condition, + GSWindow *window) +{ + gboolean finished = FALSE; + + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + { + guint32 id; + char c; + gs_debug ("keyboard command output: %s", line); + if (1 == sscanf (line, " %" G_GUINT32_FORMAT " %c", &id, &c)) + { + create_keyboard_socket (window, id); + } + } + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + window->priv->keyboard_watch_id = 0; + keyboard_command_finish (window); + return FALSE; + } + + return TRUE; +} + +static void +embed_keyboard (GSWindow *window) +{ + gboolean res; + + if (! window->priv->keyboard_enabled + || window->priv->keyboard_command == NULL) + return; + + gs_debug ("Adding embedded keyboard widget"); + + /* FIXME: verify command is safe */ + + gs_debug ("Running command: %s", window->priv->keyboard_command); + + res = spawn_on_window (window, + window->priv->keyboard_command, + &window->priv->keyboard_pid, + (GIOFunc)keyboard_command_watch, + window, + &window->priv->keyboard_watch_id); + if (! res) + { + gs_debug ("Could not start command: %s", window->priv->keyboard_command); + } +} + +static void +create_lock_socket (GSWindow *window, + guint32 id) +{ + window->priv->lock_socket = gtk_socket_new (); + window->priv->lock_box = gtk_alignment_new (0.5, 0.5, 0, 0); + gtk_widget_show (window->priv->lock_box); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->lock_box, TRUE, TRUE, 0); + + gtk_container_add (GTK_CONTAINER (window->priv->lock_box), window->priv->lock_socket); + + g_signal_connect (window->priv->lock_socket, "show", + G_CALLBACK (lock_socket_show), window); + g_signal_connect (window->priv->lock_socket, "destroy", + G_CALLBACK (lock_socket_destroyed), window); + g_signal_connect (window->priv->lock_socket, "plug_added", + G_CALLBACK (lock_plug_added), window); + g_signal_connect (window->priv->lock_socket, "plug_removed", + G_CALLBACK (lock_plug_removed), window); + + gtk_socket_add_id (GTK_SOCKET (window->priv->lock_socket), id); + + if (window->priv->keyboard_enabled) + { + embed_keyboard (window); + } +} + +static void +gs_window_dialog_finish (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Dialog finished"); + + /* make sure we finish the keyboard thing too */ + keyboard_command_finish (window); + + /* send a signal just in case */ + kill_dialog_command (window); + + if (window->priv->lock_pid > 0) + { + int exit_status; + + exit_status = wait_on_child (window->priv->lock_pid); + + g_spawn_close_pid (window->priv->lock_pid); + window->priv->lock_pid = 0; + } + + /* remove events for the case were we failed to show socket */ + remove_key_events (window); +} + +static void +maybe_kill_dialog (GSWindow *window) +{ + if (!window->priv->dialog_shake_in_progress + && window->priv->dialog_quit_requested + && window->priv->lock_pid > 0) + { + kill (window->priv->lock_pid, SIGTERM); + } +} + +/* very rudimentary animation for indicating an auth failure */ +static void +shake_dialog (GSWindow *window) +{ + int i; + guint left; + guint right; + + window->priv->dialog_shake_in_progress = TRUE; + + for (i = 0; i < 9; i++) + { + if (i % 2 == 0) + { + left = 30; + right = 0; + } + else + { + left = 0; + right = 30; + } + + if (! window->priv->lock_box) + { + break; + } + + gtk_alignment_set_padding (GTK_ALIGNMENT (window->priv->lock_box), + 0, 0, + left, + right); + + while (gtk_events_pending ()) + { + gtk_main_iteration (); + } + + g_usleep (10000); + } + + window->priv->dialog_shake_in_progress = FALSE; + maybe_kill_dialog (window); +} + +static void +window_set_dialog_up (GSWindow *window, + gboolean dialog_up) +{ + if (window->priv->dialog_up == dialog_up) + { + return; + } + + window->priv->dialog_up = dialog_up; + g_object_notify (G_OBJECT (window), "dialog-up"); +} + +static void +popdown_dialog (GSWindow *window) +{ + gs_window_dialog_finish (window); + + gtk_widget_show (window->priv->drawing_area); + + gs_window_clear (window); + set_invisible_cursor (GTK_WIDGET (window)->window, TRUE); + + window_set_dialog_up (window, FALSE); + + /* reset the pointer positions */ + window->priv->last_x = -1; + window->priv->last_y = -1; + + if (window->priv->lock_box != NULL) + { + gtk_container_remove (GTK_CONTAINER (window->priv->vbox), GTK_WIDGET (window->priv->lock_box)); + window->priv->lock_box = NULL; + } + + remove_popup_dialog_idle (window); + remove_command_watches (window); +} + +static gboolean +lock_command_watch (GIOChannel *source, + GIOCondition condition, + GSWindow *window) +{ + gboolean finished = FALSE; + + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + if (condition & G_IO_IN) + { + GIOStatus status; + GError *error = NULL; + char *line; + + line = NULL; + status = g_io_channel_read_line (source, &line, NULL, NULL, &error); + + switch (status) + { + case G_IO_STATUS_NORMAL: + gs_debug ("command output: %s", line); + + if (strstr (line, "WINDOW ID=") != NULL) + { + guint32 id; + char c; + if (1 == sscanf (line, " WINDOW ID= %" G_GUINT32_FORMAT " %c", &id, &c)) + { + create_lock_socket (window, id); + } + } + else if (strstr (line, "NOTICE=") != NULL) + { + if (strstr (line, "NOTICE=AUTH FAILED") != NULL) + { + shake_dialog (window); + } + } + else if (strstr (line, "RESPONSE=") != NULL) + { + if (strstr (line, "RESPONSE=OK") != NULL) + { + gs_debug ("Got OK response"); + window->priv->dialog_response = DIALOG_RESPONSE_OK; + } + else + { + gs_debug ("Got CANCEL response"); + window->priv->dialog_response = DIALOG_RESPONSE_CANCEL; + } + finished = TRUE; + } + else if (strstr (line, "REQUEST QUIT") != NULL) + { + gs_debug ("Got request for quit"); + window->priv->dialog_quit_requested = TRUE; + maybe_kill_dialog (window); + } + break; + case G_IO_STATUS_EOF: + finished = TRUE; + break; + case G_IO_STATUS_ERROR: + finished = TRUE; + gs_debug ("Error reading from child: %s\n", error->message); + g_error_free (error); + return FALSE; + case G_IO_STATUS_AGAIN: + default: + break; + } + + g_free (line); + } + else if (condition & G_IO_HUP) + { + finished = TRUE; + } + + if (finished) + { + popdown_dialog (window); + + if (window->priv->dialog_response == DIALOG_RESPONSE_OK) + { + add_emit_deactivated_idle (window); + } + + window->priv->lock_watch_id = 0; + + return FALSE; + } + + return TRUE; +} + +static gboolean +is_logout_enabled (GSWindow *window) +{ + double elapsed; + + if (! window->priv->logout_enabled) + { + return FALSE; + } + + if (! window->priv->logout_command) + { + return FALSE; + } + + elapsed = g_timer_elapsed (window->priv->timer, NULL); + + if (window->priv->logout_timeout < (elapsed * 1000)) + { + return TRUE; + } + + return FALSE; +} + +static gboolean +is_user_switch_enabled (GSWindow *window) +{ + return window->priv->user_switch_enabled; +} + +static void +popup_dialog (GSWindow *window) +{ + gboolean result; + char *tmp; + GString *command; + + gs_debug ("Popping up dialog"); + + tmp = g_build_filename (LIBEXECDIR, "mate-screensaver-dialog", NULL); + command = g_string_new (tmp); + g_free (tmp); + + if (is_logout_enabled (window)) + { + command = g_string_append (command, " --enable-logout"); + g_string_append_printf (command, " --logout-command='%s'", window->priv->logout_command); + } + + if (window->priv->status_message) + { + char *quoted; + + quoted = g_shell_quote (window->priv->status_message); + g_string_append_printf (command, " --status-message=%s", quoted); + g_free (quoted); + } + + if (is_user_switch_enabled (window)) + { + command = g_string_append (command, " --enable-switch"); + } + + if (gs_debug_enabled ()) + { + command = g_string_append (command, " --verbose"); + } + + gtk_widget_hide (window->priv->drawing_area); + + gs_window_clear_to_background_pixmap (window); + + set_invisible_cursor (GTK_WIDGET (window)->window, FALSE); + + window->priv->dialog_quit_requested = FALSE; + window->priv->dialog_shake_in_progress = FALSE; + + result = spawn_on_window (window, + command->str, + &window->priv->lock_pid, + (GIOFunc)lock_command_watch, + window, + &window->priv->lock_watch_id); + if (! result) + { + gs_debug ("Could not start command: %s", command->str); + } + + g_string_free (command, TRUE); +} + +static gboolean +popup_dialog_idle (GSWindow *window) +{ + popup_dialog (window); + + window->priv->popup_dialog_idle_id = 0; + + return FALSE; +} + +void +gs_window_request_unlock (GSWindow *window) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + gs_debug ("Requesting unlock"); + + if (! GTK_WIDGET_VISIBLE (GTK_WIDGET (window))) + { + gs_debug ("Request unlock but window is not visible!"); + return; + } + + if (window->priv->lock_watch_id > 0) + { + return; + } + + if (! window->priv->lock_enabled) + { + add_emit_deactivated_idle (window); + + return; + } + + if (window->priv->popup_dialog_idle_id == 0) + { + add_popup_dialog_idle (window); + } + + window_set_dialog_up (window, TRUE); +} + +void +gs_window_cancel_unlock_request (GSWindow *window) +{ + /* FIXME: This is a bit of a hammer approach... + * Maybe we should send a delete-event to + * the plug? + */ + g_return_if_fail (GS_IS_WINDOW (window)); + + popdown_dialog (window); +} + +void +gs_window_set_lock_enabled (GSWindow *window, + gboolean lock_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->lock_enabled == lock_enabled) + { + return; + } + + window->priv->lock_enabled = lock_enabled; + g_object_notify (G_OBJECT (window), "lock-enabled"); +} + +void +gs_window_set_screen (GSWindow *window, + GdkScreen *screen) +{ + + g_return_if_fail (GS_IS_WINDOW (window)); + g_return_if_fail (GDK_IS_SCREEN (screen)); + + gtk_window_set_screen (GTK_WINDOW (window), screen); +} + +GdkScreen * +gs_window_get_screen (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), NULL); + + return GTK_WINDOW (window)->screen; +} + +void +gs_window_set_keyboard_enabled (GSWindow *window, + gboolean enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->keyboard_enabled = enabled; +} + +void +gs_window_set_keyboard_command (GSWindow *window, + const char *command) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->keyboard_command); + + if (command != NULL) + { + window->priv->keyboard_command = g_strdup (command); + } + else + { + window->priv->keyboard_command = NULL; + } +} + +void +gs_window_set_logout_enabled (GSWindow *window, + gboolean logout_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->logout_enabled = logout_enabled; +} + +void +gs_window_set_user_switch_enabled (GSWindow *window, + gboolean user_switch_enabled) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + window->priv->user_switch_enabled = user_switch_enabled; +} + +void +gs_window_set_logout_timeout (GSWindow *window, + glong logout_timeout) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (logout_timeout < 0) + { + window->priv->logout_timeout = 0; + } + else + { + window->priv->logout_timeout = logout_timeout; + } +} + +void +gs_window_set_logout_command (GSWindow *window, + const char *command) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->logout_command); + + if (command) + { + window->priv->logout_command = g_strdup (command); + } + else + { + window->priv->logout_command = NULL; + } +} + +void +gs_window_set_status_message (GSWindow *window, + const char *status_message) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + g_free (window->priv->status_message); + window->priv->status_message = g_strdup (status_message); +} + +void +gs_window_set_monitor (GSWindow *window, + int monitor) +{ + g_return_if_fail (GS_IS_WINDOW (window)); + + if (window->priv->monitor == monitor) + { + return; + } + + window->priv->monitor = monitor; + + gtk_widget_queue_resize (GTK_WIDGET (window)); + + g_object_notify (G_OBJECT (window), "monitor"); +} + +int +gs_window_get_monitor (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), -1); + + return window->priv->monitor; +} + +static void +gs_window_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GSWindow *self; + + self = GS_WINDOW (object); + + switch (prop_id) + { + case PROP_LOCK_ENABLED: + gs_window_set_lock_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_ENABLED: + gs_window_set_keyboard_enabled (self, g_value_get_boolean (value)); + break; + case PROP_KEYBOARD_COMMAND: + gs_window_set_keyboard_command (self, g_value_get_string (value)); + break; + case PROP_LOGOUT_ENABLED: + gs_window_set_logout_enabled (self, g_value_get_boolean (value)); + break; + case PROP_LOGOUT_COMMAND: + gs_window_set_logout_command (self, g_value_get_string (value)); + break; + case PROP_STATUS_MESSAGE: + gs_window_set_status_message (self, g_value_get_string (value)); + break; + case PROP_LOGOUT_TIMEOUT: + gs_window_set_logout_timeout (self, g_value_get_long (value)); + break; + case PROP_MONITOR: + gs_window_set_monitor (self, g_value_get_int (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gs_window_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GSWindow *self; + + self = GS_WINDOW (object); + + switch (prop_id) + { + case PROP_LOCK_ENABLED: + g_value_set_boolean (value, self->priv->lock_enabled); + break; + case PROP_KEYBOARD_ENABLED: + g_value_set_boolean (value, self->priv->keyboard_enabled); + break; + case PROP_KEYBOARD_COMMAND: + g_value_set_string (value, self->priv->keyboard_command); + break; + case PROP_LOGOUT_ENABLED: + g_value_set_boolean (value, self->priv->logout_enabled); + break; + case PROP_LOGOUT_COMMAND: + g_value_set_string (value, self->priv->logout_command); + break; + case PROP_STATUS_MESSAGE: + g_value_set_string (value, self->priv->status_message); + break; + case PROP_LOGOUT_TIMEOUT: + g_value_set_long (value, self->priv->logout_timeout); + break; + case PROP_MONITOR: + g_value_set_int (value, self->priv->monitor); + break; + case PROP_OBSCURED: + g_value_set_boolean (value, self->priv->obscured); + break; + case PROP_DIALOG_UP: + g_value_set_boolean (value, self->priv->dialog_up); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +queue_key_event (GSWindow *window, + GdkEventKey *event) +{ + /* Eat the first return, enter, escape, or space */ + if (window->priv->key_events == NULL + && (event->keyval == GDK_Return + || event->keyval == GDK_KP_Enter + || event->keyval == GDK_Escape + || event->keyval == GDK_space)) + { + return; + } + + /* Only cache MAX_QUEUED_EVENTS key events. If there are any more than this then + something is wrong */ + /* Don't queue keys that may cause focus navigation in the dialog */ + if (g_list_length (window->priv->key_events) < MAX_QUEUED_EVENTS + && event->keyval != GDK_Tab + && event->keyval != GDK_Up + && event->keyval != GDK_Down) + { + window->priv->key_events = g_list_prepend (window->priv->key_events, + gdk_event_copy ((GdkEvent *)event)); + } +} + +static gboolean +maybe_handle_activity (GSWindow *window) +{ + gboolean handled; + + handled = FALSE; + + /* if we already have a socket then don't bother */ + if (! window->priv->lock_socket + && GTK_WIDGET_IS_SENSITIVE (GTK_WIDGET (window))) + { + g_signal_emit (window, signals [ACTIVITY], 0, &handled); + } + + return handled; +} + +static gboolean +gs_window_real_key_press_event (GtkWidget *widget, + GdkEventKey *event) +{ + /*g_message ("KEY PRESS state: %u keyval %u", event->state, event->keyval);*/ + + /* Ignore brightness keys */ + if (event->hardware_keycode == 101 || event->hardware_keycode == 212) + { + gs_debug ("Ignoring brightness keys"); + return TRUE; + } + + maybe_handle_activity (GS_WINDOW (widget)); + + queue_key_event (GS_WINDOW (widget), event); + + if (GTK_WIDGET_CLASS (gs_window_parent_class)->key_press_event) + { + GTK_WIDGET_CLASS (gs_window_parent_class)->key_press_event (widget, event); + } + + return TRUE; +} + +static gboolean +gs_window_real_motion_notify_event (GtkWidget *widget, + GdkEventMotion *event) +{ + GSWindow *window; + gdouble distance; + gdouble min_distance; + gdouble min_percentage = 0.1; + GdkScreen *screen; + + window = GS_WINDOW (widget); + + screen = gs_window_get_screen (window); + min_distance = gdk_screen_get_width (screen) * min_percentage; + + /* if the last position was not set then don't detect motion */ + if (window->priv->last_x < 0 || window->priv->last_y < 0) + { + window->priv->last_x = event->x; + window->priv->last_y = event->y; + + return FALSE; + } + + /* just an approximate distance */ + distance = MAX (ABS (window->priv->last_x - event->x), + ABS (window->priv->last_y - event->y)); + + if (distance > min_distance) + { + maybe_handle_activity (window); + + window->priv->last_x = -1; + window->priv->last_y = -1; + } + + return FALSE; +} + +static gboolean +gs_window_real_button_press_event (GtkWidget *widget, + GdkEventButton *event) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + maybe_handle_activity (window); + + return FALSE; +} + +static gboolean +gs_window_real_scroll_event (GtkWidget *widget, + GdkEventScroll *event) +{ + GSWindow *window; + + window = GS_WINDOW (widget); + maybe_handle_activity (window); + + return FALSE; +} + +static void +gs_window_real_size_request (GtkWidget *widget, + GtkRequisition *requisition) +{ + GSWindow *window; + GtkBin *bin; + GdkRectangle old_geometry; + int position_changed = FALSE; + int size_changed = FALSE; + + window = GS_WINDOW (widget); + bin = GTK_BIN (widget); + + if (bin->child && GTK_WIDGET_VISIBLE (bin->child)) + { + gtk_widget_size_request (bin->child, requisition); + } + + old_geometry = window->priv->geometry; + + update_geometry (window); + + requisition->width = window->priv->geometry.width; + requisition->height = window->priv->geometry.height; + + if (! GTK_WIDGET_REALIZED (widget)) + { + return; + } + + if (old_geometry.width != window->priv->geometry.width || + old_geometry.height != window->priv->geometry.height) + { + size_changed = TRUE; + } + + if (old_geometry.x != window->priv->geometry.x || + old_geometry.y != window->priv->geometry.y) + { + position_changed = TRUE; + } + + gs_window_move_resize_window (window, position_changed, size_changed); +} + +static gboolean +gs_window_real_grab_broken (GtkWidget *widget, + GdkEventGrabBroken *event) +{ + if (event->grab_window != NULL) + { + gs_debug ("Grab broken on window %X %s, new grab on window %X", + (guint32) GDK_WINDOW_XID (event->window), + event->keyboard ? "keyboard" : "pointer", + (guint32) GDK_WINDOW_XID (event->grab_window)); + } + else + { + gs_debug ("Grab broken on window %X %s, new grab is outside application", + (guint32) GDK_WINDOW_XID (event->window), + event->keyboard ? "keyboard" : "pointer"); + } + + return FALSE; +} + +gboolean +gs_window_is_obscured (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + return window->priv->obscured; +} + +gboolean +gs_window_is_dialog_up (GSWindow *window) +{ + g_return_val_if_fail (GS_IS_WINDOW (window), FALSE); + + return window->priv->dialog_up; +} + +static void +window_set_obscured (GSWindow *window, + gboolean obscured) +{ + if (window->priv->obscured == obscured) + { + return; + } + + window->priv->obscured = obscured; + g_object_notify (G_OBJECT (window), "obscured"); +} + +static gboolean +gs_window_real_visibility_notify_event (GtkWidget *widget, + GdkEventVisibility *event) +{ + switch (event->state) + { + case GDK_VISIBILITY_FULLY_OBSCURED: + window_set_obscured (GS_WINDOW (widget), TRUE); + break; + case GDK_VISIBILITY_PARTIAL: + break; + case GDK_VISIBILITY_UNOBSCURED: + window_set_obscured (GS_WINDOW (widget), FALSE); + break; + default: + break; + } + + return FALSE; +} + +static void +gs_window_class_init (GSWindowClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->finalize = gs_window_finalize; + object_class->get_property = gs_window_get_property; + object_class->set_property = gs_window_set_property; + + widget_class->show = gs_window_real_show; + widget_class->hide = gs_window_real_hide; + widget_class->realize = gs_window_real_realize; + widget_class->unrealize = gs_window_real_unrealize; + widget_class->key_press_event = gs_window_real_key_press_event; + widget_class->motion_notify_event = gs_window_real_motion_notify_event; + widget_class->button_press_event = gs_window_real_button_press_event; + widget_class->scroll_event = gs_window_real_scroll_event; + widget_class->size_request = gs_window_real_size_request; + widget_class->grab_broken_event = gs_window_real_grab_broken; + widget_class->visibility_notify_event = gs_window_real_visibility_notify_event; + + g_type_class_add_private (klass, sizeof (GSWindowPrivate)); + + signals [ACTIVITY] = + g_signal_new ("activity", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWindowClass, activity), + NULL, + NULL, + gs_marshal_BOOLEAN__VOID, + G_TYPE_BOOLEAN, + 0); + signals [DEACTIVATED] = + g_signal_new ("deactivated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GSWindowClass, deactivated), + NULL, + NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + g_object_class_install_property (object_class, + PROP_OBSCURED, + g_param_spec_boolean ("obscured", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_DIALOG_UP, + g_param_spec_boolean ("dialog-up", + NULL, + NULL, + FALSE, + G_PARAM_READABLE)); + g_object_class_install_property (object_class, + PROP_LOCK_ENABLED, + g_param_spec_boolean ("lock-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_ENABLED, + g_param_spec_boolean ("logout-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_TIMEOUT, + g_param_spec_long ("logout-timeout", + NULL, + NULL, + -1, + G_MAXLONG, + 0, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_LOGOUT_COMMAND, + g_param_spec_string ("logout-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_STATUS_MESSAGE, + g_param_spec_string ("status-message", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_KEYBOARD_ENABLED, + g_param_spec_boolean ("keyboard-enabled", + NULL, + NULL, + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_KEYBOARD_COMMAND, + g_param_spec_string ("keyboard-command", + NULL, + NULL, + NULL, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_MONITOR, + g_param_spec_int ("monitor", + "Xinerama monitor", + "The monitor (in terms of Xinerama) which the window is on", + 0, + G_MAXINT, + 0, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); + +} + +static void +create_info_bar (GSWindow *window) +{ + window->priv->info_bar = gtk_info_bar_new (); + gtk_widget_set_no_show_all (window->priv->info_bar, TRUE); + gtk_box_pack_end (GTK_BOX (window->priv->vbox), window->priv->info_bar, FALSE, FALSE, 0); +} + +static void +gs_window_init (GSWindow *window) +{ + window->priv = GS_WINDOW_GET_PRIVATE (window); + + window->priv->geometry.x = -1; + window->priv->geometry.y = -1; + window->priv->geometry.width = -1; + window->priv->geometry.height = -1; + + window->priv->last_x = -1; + window->priv->last_y = -1; + + gtk_window_set_decorated (GTK_WINDOW (window), FALSE); + + gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE); + gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE); + + gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); + + gtk_window_fullscreen (GTK_WINDOW (window)); + + gtk_widget_set_events (GTK_WIDGET (window), + gtk_widget_get_events (GTK_WIDGET (window)) + | GDK_POINTER_MOTION_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_KEY_PRESS_MASK + | GDK_KEY_RELEASE_MASK + | GDK_EXPOSURE_MASK + | GDK_VISIBILITY_NOTIFY_MASK + | GDK_ENTER_NOTIFY_MASK + | GDK_LEAVE_NOTIFY_MASK); + + window->priv->vbox = gtk_vbox_new (FALSE, 12); + gtk_widget_show (window->priv->vbox); + gtk_container_add (GTK_CONTAINER (window), window->priv->vbox); + + window->priv->drawing_area = gtk_drawing_area_new (); + gtk_widget_show (window->priv->drawing_area); + gtk_box_pack_start (GTK_BOX (window->priv->vbox), window->priv->drawing_area, TRUE, TRUE, 0); + create_info_bar (window); + + force_no_pixmap_background (window->priv->drawing_area); +} + +static void +remove_command_watches (GSWindow *window) +{ + if (window->priv->lock_watch_id != 0) + { + g_source_remove (window->priv->lock_watch_id); + window->priv->lock_watch_id = 0; + } + if (window->priv->keyboard_watch_id != 0) + { + g_source_remove (window->priv->keyboard_watch_id); + window->priv->keyboard_watch_id = 0; + } +} + +static void +gs_window_finalize (GObject *object) +{ + GSWindow *window; + + g_return_if_fail (object != NULL); + g_return_if_fail (GS_IS_WINDOW (object)); + + window = GS_WINDOW (object); + + g_return_if_fail (window->priv != NULL); + + g_free (window->priv->logout_command); + g_free (window->priv->keyboard_command); + + if (window->priv->info_bar_timer_id > 0) + { + g_source_remove (window->priv->info_bar_timer_id); + } + + remove_watchdog_timer (window); + remove_popup_dialog_idle (window); + + if (window->priv->timer) + { + g_timer_destroy (window->priv->timer); + } + + remove_key_events (window); + + remove_command_watches (window); + + gs_window_dialog_finish (window); + + if (window->priv->background_pixmap) + { + g_object_unref (window->priv->background_pixmap); + } + + G_OBJECT_CLASS (gs_window_parent_class)->finalize (object); +} + +GSWindow * +gs_window_new (GdkScreen *screen, + int monitor, + gboolean lock_enabled) +{ + GObject *result; + + result = g_object_new (GS_TYPE_WINDOW, + "type", GTK_WINDOW_POPUP, + "screen", screen, + "monitor", monitor, + "lock-enabled", lock_enabled, + NULL); + + return GS_WINDOW (result); +} diff --git a/src/gs-window.h b/src/gs-window.h new file mode 100644 index 0000000..9c8aee3 --- /dev/null +++ b/src/gs-window.h @@ -0,0 +1,106 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_WINDOW_H +#define __GS_WINDOW_H + +#include +#include + +G_BEGIN_DECLS + +#define GS_TYPE_WINDOW (gs_window_get_type ()) +#define GS_WINDOW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_WINDOW, GSWindow)) +#define GS_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_WINDOW, GSWindowClass)) +#define GS_IS_WINDOW(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_WINDOW)) +#define GS_IS_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_WINDOW)) +#define GS_WINDOW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_WINDOW, GSWindowClass)) + +typedef struct GSWindowPrivate GSWindowPrivate; + +typedef struct +{ + GtkWindow window; + + GSWindowPrivate *priv; +} GSWindow; + +typedef struct +{ + GtkWindowClass parent_class; + + gboolean (* activity) (GSWindow *window); + void (* deactivated) (GSWindow *window); + void (* dialog_up) (GSWindow *window); + void (* dialog_down) (GSWindow *window); +} GSWindowClass; + +GType gs_window_get_type (void); + +gboolean gs_window_is_obscured (GSWindow *window); +gboolean gs_window_is_dialog_up (GSWindow *window); + +void gs_window_set_screen (GSWindow *window, + GdkScreen *screen); +GdkScreen * gs_window_get_screen (GSWindow *window); +void gs_window_set_monitor (GSWindow *window, + int monitor); +int gs_window_get_monitor (GSWindow *window); + +void gs_window_set_background_pixmap (GSWindow *window, + GdkPixmap *pixmap); +void gs_window_set_lock_enabled (GSWindow *window, + gboolean lock_enabled); +void gs_window_set_logout_enabled (GSWindow *window, + gboolean logout_enabled); +void gs_window_set_keyboard_enabled (GSWindow *window, + gboolean enabled); +void gs_window_set_keyboard_command (GSWindow *window, + const char *command); +void gs_window_set_user_switch_enabled (GSWindow *window, + gboolean user_switch_enabled); +void gs_window_set_logout_timeout (GSWindow *window, + glong timeout); +void gs_window_set_logout_command (GSWindow *window, + const char *command); +void gs_window_set_status_message (GSWindow *window, + const char *status_message); +void gs_window_show_message (GSWindow *window, + const char *summary, + const char *body, + const char *icon); + +void gs_window_request_unlock (GSWindow *window); +void gs_window_cancel_unlock_request (GSWindow *window); + +GSWindow * gs_window_new (GdkScreen *screen, + int monitor, + gboolean lock_enabled); +void gs_window_show (GSWindow *window); +void gs_window_destroy (GSWindow *window); +GdkWindow * gs_window_get_gdk_window (GSWindow *window); +GtkWidget * gs_window_get_drawing_area (GSWindow *window); +void gs_window_clear (GSWindow *window); + +G_END_DECLS + +#endif /* __GS_WINDOW_H */ diff --git a/src/gs-window.h.orig b/src/gs-window.h.orig new file mode 100644 index 0000000..39537fe --- /dev/null +++ b/src/gs-window.h.orig @@ -0,0 +1,106 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __GS_WINDOW_H +#define __GS_WINDOW_H + +#include +#include + +G_BEGIN_DECLS + +#define GS_TYPE_WINDOW (gs_window_get_type ()) +#define GS_WINDOW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GS_TYPE_WINDOW, GSWindow)) +#define GS_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GS_TYPE_WINDOW, GSWindowClass)) +#define GS_IS_WINDOW(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GS_TYPE_WINDOW)) +#define GS_IS_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GS_TYPE_WINDOW)) +#define GS_WINDOW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GS_TYPE_WINDOW, GSWindowClass)) + +typedef struct GSWindowPrivate GSWindowPrivate; + +typedef struct +{ + GtkWindow window; + + GSWindowPrivate *priv; +} GSWindow; + +typedef struct +{ + GtkWindowClass parent_class; + + gboolean (* activity) (GSWindow *window); + void (* deactivated) (GSWindow *window); + void (* dialog_up) (GSWindow *window); + void (* dialog_down) (GSWindow *window); +} GSWindowClass; + +GType gs_window_get_type (void); + +gboolean gs_window_is_obscured (GSWindow *window); +gboolean gs_window_is_dialog_up (GSWindow *window); + +void gs_window_set_screen (GSWindow *window, + GdkScreen *screen); +GdkScreen * gs_window_get_screen (GSWindow *window); +void gs_window_set_monitor (GSWindow *window, + int monitor); +int gs_window_get_monitor (GSWindow *window); + +void gs_window_set_background_pixmap (GSWindow *window, + GdkPixmap *pixmap); +void gs_window_set_lock_enabled (GSWindow *window, + gboolean lock_enabled); +void gs_window_set_logout_enabled (GSWindow *window, + gboolean logout_enabled); +void gs_window_set_keyboard_enabled (GSWindow *window, + gboolean enabled); +void gs_window_set_keyboard_command (GSWindow *window, + const char *command); +void gs_window_set_user_switch_enabled (GSWindow *window, + gboolean user_switch_enabled); +void gs_window_set_logout_timeout (GSWindow *window, + glong timeout); +void gs_window_set_logout_command (GSWindow *window, + const char *command); +void gs_window_set_status_message (GSWindow *window, + const char *status_message); +void gs_window_show_message (GSWindow *window, + const char *summary, + const char *body, + const char *icon); + +void gs_window_request_unlock (GSWindow *window); +void gs_window_cancel_unlock_request (GSWindow *window); + +GSWindow * gs_window_new (GdkScreen *screen, + int monitor, + gboolean lock_enabled); +void gs_window_show (GSWindow *window); +void gs_window_destroy (GSWindow *window); +GdkWindow * gs_window_get_gdk_window (GSWindow *window); +GtkWidget * gs_window_get_drawing_area (GSWindow *window); +void gs_window_clear (GSWindow *window); + +G_END_DECLS + +#endif /* __GS_WINDOW_H */ diff --git a/src/mate-screensaver-command.c b/src/mate-screensaver-command.c new file mode 100644 index 0000000..d6f0459 --- /dev/null +++ b/src/mate-screensaver-command.c @@ -0,0 +1,551 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#define DBUS_API_SUBJECT_TO_CHANGE +#include +#include +#include + +#define GS_SERVICE "org.mate.ScreenSaver" +#define GS_PATH "/org/mate/ScreenSaver" +#define GS_INTERFACE "org.mate.ScreenSaver" + +/* this is for dbus < 0.3 */ +#if ((DBUS_VERSION_MAJOR == 0) && (DBUS_VERSION_MINOR < 30)) +#define dbus_bus_name_has_owner(connection, name, err) dbus_bus_service_exists(connection, name, err) +#endif + +static gboolean do_quit = FALSE; +static gboolean do_lock = FALSE; +static gboolean do_cycle = FALSE; +static gboolean do_activate = FALSE; +static gboolean do_deactivate = FALSE; +static gboolean do_version = FALSE; +static gboolean do_poke = FALSE; +static gboolean do_inhibit = FALSE; + +static gboolean do_query = FALSE; +static gboolean do_time = FALSE; + +static char *inhibit_reason = NULL; +static char *inhibit_application = NULL; + +static GOptionEntry entries [] = +{ + { + "exit", 0, 0, G_OPTION_ARG_NONE, &do_quit, + N_("Causes the screensaver to exit gracefully"), NULL + }, + { + "query", 'q', 0, G_OPTION_ARG_NONE, &do_query, + N_("Query the state of the screensaver"), NULL + }, + { + "time", 't', 0, G_OPTION_ARG_NONE, &do_time, + N_("Query the length of time the screensaver has been active"), NULL + }, + { + "lock", 'l', 0, G_OPTION_ARG_NONE, &do_lock, + N_("Tells the running screensaver process to lock the screen immediately"), NULL + }, + { + "cycle", 'c', 0, G_OPTION_ARG_NONE, &do_cycle, + N_("If the screensaver is active then switch to another graphics demo"), NULL + }, + { + "activate", 'a', 0, G_OPTION_ARG_NONE, &do_activate, + N_("Turn the screensaver on (blank the screen)"), NULL + }, + { + "deactivate", 'd', 0, G_OPTION_ARG_NONE, &do_deactivate, + N_("If the screensaver is active then deactivate it (un-blank the screen)"), NULL + }, + { + "poke", 'p', 0, G_OPTION_ARG_NONE, &do_poke, + N_("Poke the running screensaver to simulate user activity"), NULL + }, + { + "inhibit", 'i', 0, G_OPTION_ARG_NONE, &do_inhibit, + N_("Inhibit the screensaver from activating. Command blocks while inhibit is active."), NULL + }, + { + "application-name", 'n', 0, G_OPTION_ARG_STRING, &inhibit_application, + N_("The calling application that is inhibiting the screensaver"), NULL + }, + { + "reason", 'r', 0, G_OPTION_ARG_STRING, &inhibit_reason, + N_("The reason for inhibiting the screensaver"), NULL + }, + { + "version", 'V', 0, G_OPTION_ARG_NONE, &do_version, + N_("Version of this application"), NULL + }, + { NULL } +}; + +static GMainLoop *loop = NULL; + +static gboolean +screensaver_is_running (DBusConnection *connection) +{ + DBusError error; + gboolean exists; + + g_return_val_if_fail (connection != NULL, FALSE); + + dbus_error_init (&error); + exists = dbus_bus_name_has_owner (connection, GS_SERVICE, &error); + if (dbus_error_is_set (&error)) + dbus_error_free (&error); + + return exists; +} + +static DBusMessage * +screensaver_send_message_inhibit (DBusConnection *connection, + const char *application, + const char *reason) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, "Inhibit"); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &application); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &reason); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_bool (DBusConnection *connection, + const char *name, + gboolean value) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &value); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_void (DBusConnection *connection, + const char *name, + gboolean expect_reply) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + if (! expect_reply) + { + if (!dbus_connection_send (connection, message, NULL)) + g_warning ("could not send message"); + reply = NULL; + } + else + { + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + } + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static char ** +get_string_from_iter (DBusMessageIter *iter, + int *num_elements) +{ + int count; + char **buffer; + + if (num_elements != NULL) + { + *num_elements = 0; + } + + count = 0; + buffer = (char **)malloc (sizeof (char *) * 8); + + if (buffer == NULL) + { + goto oom; + } + + buffer[0] = NULL; + while (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_STRING) + { + const char *value; + char *str; + + if ((count % 8) == 0 && count != 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 8)); + if (buffer == NULL) + { + goto oom; + } + } + + dbus_message_iter_get_basic (iter, &value); + str = strdup (value); + if (str == NULL) + { + goto oom; + } + + buffer[count] = str; + + dbus_message_iter_next (iter); + count++; + } + + if ((count % 8) == 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 1)); + if (buffer == NULL) + { + goto oom; + } + } + + buffer[count] = NULL; + if (num_elements != NULL) + { + *num_elements = count; + } + return buffer; + +oom: + g_debug ("%s %d : error allocating memory\n", __FILE__, __LINE__); + return NULL; + +} + +static gboolean +do_command (DBusConnection *connection) +{ + DBusMessage *reply; + + if (do_quit) + { + reply = screensaver_send_message_void (connection, "Quit", FALSE); + goto done; + } + + if (do_query) + { + DBusMessageIter iter; + DBusMessageIter array; + dbus_bool_t v; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + g_print (_("The screensaver is %s\n"), v ? _("active") : _("inactive")); + + dbus_message_unref (reply); + + reply = screensaver_send_message_void (connection, "GetInhibitors", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_recurse (&iter, &array); + + if (dbus_message_iter_get_arg_type (&array) == DBUS_TYPE_INVALID) + { + g_print (_("The screensaver is not inhibited\n")); + } + else + { + char **inhibitors; + int i; + int num; + + g_print (_("The screensaver is being inhibited by:\n")); + inhibitors = get_string_from_iter (&array, &num); + for (i = 0; i < num; i++) + { + g_print ("\t%s\n", inhibitors[i]); + } + g_strfreev (inhibitors); + } + + dbus_message_unref (reply); + } + + if (do_time) + { + DBusMessageIter iter; + dbus_bool_t v; + dbus_int32_t t; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + dbus_message_unref (reply); + + if (v) + { + + reply = screensaver_send_message_void (connection, "GetActiveTime", TRUE); + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &t); + g_print (_("The screensaver has been active for %d seconds.\n"), t); + + dbus_message_unref (reply); + } + else + { + g_print (_("The screensaver is not currently active.\n")); + } + } + + if (do_lock) + { + reply = screensaver_send_message_void (connection, "Lock", FALSE); + } + + if (do_cycle) + { + reply = screensaver_send_message_void (connection, "Cycle", FALSE); + } + + if (do_poke) + { + reply = screensaver_send_message_void (connection, "SimulateUserActivity", FALSE); + } + + if (do_activate) + { + reply = screensaver_send_message_bool (connection, "SetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_deactivate) + { + reply = screensaver_send_message_bool (connection, "SetActive", FALSE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_inhibit) + { + reply = screensaver_send_message_inhibit (connection, + inhibit_application ? inhibit_application : "Unknown", + inhibit_reason ? inhibit_reason : "Unknown"); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + + return FALSE; + } + +done: + g_main_loop_quit (loop); + + return FALSE; +} + +int +main (int argc, + char **argv) +{ + DBusConnection *connection; + DBusError dbus_error; + GOptionContext *context; + gboolean retval; + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + g_type_init (); + + g_set_prgname (argv[0]); + + if (setlocale (LC_ALL, "") == NULL) + g_warning ("Locale not understood by C library, internationalization will not work\n"); + + context = g_option_context_new (NULL); + g_option_context_add_main_entries (context, entries, NULL); + retval = g_option_context_parse (context, &argc, &argv, &error); + + g_option_context_free (context); + + if (! retval) + { + g_warning ("%s", error->message); + g_error_free (error); + exit (1); + } + + if (do_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + dbus_error_init (&dbus_error); + connection = dbus_bus_get (DBUS_BUS_SESSION, &dbus_error); + if (! connection) + { + g_message ("Failed to connect to the D-BUS daemon: %s", dbus_error.message); + dbus_error_free (&dbus_error); + exit (1); + } + + dbus_connection_setup_with_g_main (connection, NULL); + + if (! screensaver_is_running (connection)) + { + g_message ("Screensaver is not running!"); + exit (1); + } + + g_idle_add ((GSourceFunc)do_command, connection); + + loop = g_main_loop_new (NULL, FALSE); + g_main_loop_run (loop); + + return 0; +} diff --git a/src/mate-screensaver-command.c.orig b/src/mate-screensaver-command.c.orig new file mode 100644 index 0000000..441f81e --- /dev/null +++ b/src/mate-screensaver-command.c.orig @@ -0,0 +1,551 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include + +#define DBUS_API_SUBJECT_TO_CHANGE +#include +#include +#include + +#define GS_SERVICE "org.mate.ScreenSaver" +#define GS_PATH "/org/mate/ScreenSaver" +#define GS_INTERFACE "org.mate.ScreenSaver" + +/* this is for dbus < 0.3 */ +#if ((DBUS_VERSION_MAJOR == 0) && (DBUS_VERSION_MINOR < 30)) +#define dbus_bus_name_has_owner(connection, name, err) dbus_bus_service_exists(connection, name, err) +#endif + +static gboolean do_quit = FALSE; +static gboolean do_lock = FALSE; +static gboolean do_cycle = FALSE; +static gboolean do_activate = FALSE; +static gboolean do_deactivate = FALSE; +static gboolean do_version = FALSE; +static gboolean do_poke = FALSE; +static gboolean do_inhibit = FALSE; + +static gboolean do_query = FALSE; +static gboolean do_time = FALSE; + +static char *inhibit_reason = NULL; +static char *inhibit_application = NULL; + +static GOptionEntry entries [] = +{ + { + "exit", 0, 0, G_OPTION_ARG_NONE, &do_quit, + N_("Causes the screensaver to exit gracefully"), NULL + }, + { + "query", 'q', 0, G_OPTION_ARG_NONE, &do_query, + N_("Query the state of the screensaver"), NULL + }, + { + "time", 't', 0, G_OPTION_ARG_NONE, &do_time, + N_("Query the length of time the screensaver has been active"), NULL + }, + { + "lock", 'l', 0, G_OPTION_ARG_NONE, &do_lock, + N_("Tells the running screensaver process to lock the screen immediately"), NULL + }, + { + "cycle", 'c', 0, G_OPTION_ARG_NONE, &do_cycle, + N_("If the screensaver is active then switch to another graphics demo"), NULL + }, + { + "activate", 'a', 0, G_OPTION_ARG_NONE, &do_activate, + N_("Turn the screensaver on (blank the screen)"), NULL + }, + { + "deactivate", 'd', 0, G_OPTION_ARG_NONE, &do_deactivate, + N_("If the screensaver is active then deactivate it (un-blank the screen)"), NULL + }, + { + "poke", 'p', 0, G_OPTION_ARG_NONE, &do_poke, + N_("Poke the running screensaver to simulate user activity"), NULL + }, + { + "inhibit", 'i', 0, G_OPTION_ARG_NONE, &do_inhibit, + N_("Inhibit the screensaver from activating. Command blocks while inhibit is active."), NULL + }, + { + "application-name", 'n', 0, G_OPTION_ARG_STRING, &inhibit_application, + N_("The calling application that is inhibiting the screensaver"), NULL + }, + { + "reason", 'r', 0, G_OPTION_ARG_STRING, &inhibit_reason, + N_("The reason for inhibiting the screensaver"), NULL + }, + { + "version", 'V', 0, G_OPTION_ARG_NONE, &do_version, + N_("Version of this application"), NULL + }, + { NULL } +}; + +static GMainLoop *loop = NULL; + +static gboolean +screensaver_is_running (DBusConnection *connection) +{ + DBusError error; + gboolean exists; + + g_return_val_if_fail (connection != NULL, FALSE); + + dbus_error_init (&error); + exists = dbus_bus_name_has_owner (connection, GS_SERVICE, &error); + if (dbus_error_is_set (&error)) + dbus_error_free (&error); + + return exists; +} + +static DBusMessage * +screensaver_send_message_inhibit (DBusConnection *connection, + const char *application, + const char *reason) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, "Inhibit"); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &application); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &reason); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_bool (DBusConnection *connection, + const char *name, + gboolean value) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + DBusMessageIter iter; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + dbus_message_iter_init_append (message, &iter); + dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &value); + + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static DBusMessage * +screensaver_send_message_void (DBusConnection *connection, + const char *name, + gboolean expect_reply) +{ + DBusMessage *message; + DBusMessage *reply; + DBusError error; + + g_return_val_if_fail (connection != NULL, NULL); + g_return_val_if_fail (name != NULL, NULL); + + dbus_error_init (&error); + + message = dbus_message_new_method_call (GS_SERVICE, GS_PATH, GS_INTERFACE, name); + if (message == NULL) + { + g_warning ("Couldn't allocate the dbus message"); + return NULL; + } + + if (! expect_reply) + { + if (!dbus_connection_send (connection, message, NULL)) + g_warning ("could not send message"); + reply = NULL; + } + else + { + reply = dbus_connection_send_with_reply_and_block (connection, + message, + -1, &error); + if (dbus_error_is_set (&error)) + { + g_warning ("%s raised:\n %s\n\n", error.name, error.message); + reply = NULL; + } + } + dbus_connection_flush (connection); + + dbus_message_unref (message); + dbus_error_free (&error); + + return reply; +} + +static char ** +get_string_from_iter (DBusMessageIter *iter, + int *num_elements) +{ + int count; + char **buffer; + + if (num_elements != NULL) + { + *num_elements = 0; + } + + count = 0; + buffer = (char **)malloc (sizeof (char *) * 8); + + if (buffer == NULL) + { + goto oom; + } + + buffer[0] = NULL; + while (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_STRING) + { + const char *value; + char *str; + + if ((count % 8) == 0 && count != 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 8)); + if (buffer == NULL) + { + goto oom; + } + } + + dbus_message_iter_get_basic (iter, &value); + str = strdup (value); + if (str == NULL) + { + goto oom; + } + + buffer[count] = str; + + dbus_message_iter_next (iter); + count++; + } + + if ((count % 8) == 0) + { + buffer = realloc (buffer, sizeof (char *) * (count + 1)); + if (buffer == NULL) + { + goto oom; + } + } + + buffer[count] = NULL; + if (num_elements != NULL) + { + *num_elements = count; + } + return buffer; + +oom: + g_debug ("%s %d : error allocating memory\n", __FILE__, __LINE__); + return NULL; + +} + +static gboolean +do_command (DBusConnection *connection) +{ + DBusMessage *reply; + + if (do_quit) + { + reply = screensaver_send_message_void (connection, "Quit", FALSE); + goto done; + } + + if (do_query) + { + DBusMessageIter iter; + DBusMessageIter array; + dbus_bool_t v; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + g_print (_("The screensaver is %s\n"), v ? _("active") : _("inactive")); + + dbus_message_unref (reply); + + reply = screensaver_send_message_void (connection, "GetInhibitors", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_recurse (&iter, &array); + + if (dbus_message_iter_get_arg_type (&array) == DBUS_TYPE_INVALID) + { + g_print (_("The screensaver is not inhibited\n")); + } + else + { + char **inhibitors; + int i; + int num; + + g_print (_("The screensaver is being inhibited by:\n")); + inhibitors = get_string_from_iter (&array, &num); + for (i = 0; i < num; i++) + { + g_print ("\t%s\n", inhibitors[i]); + } + g_strfreev (inhibitors); + } + + dbus_message_unref (reply); + } + + if (do_time) + { + DBusMessageIter iter; + dbus_bool_t v; + dbus_int32_t t; + + reply = screensaver_send_message_void (connection, "GetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &v); + dbus_message_unref (reply); + + if (v) + { + + reply = screensaver_send_message_void (connection, "GetActiveTime", TRUE); + dbus_message_iter_init (reply, &iter); + dbus_message_iter_get_basic (&iter, &t); + g_print (_("The screensaver has been active for %d seconds.\n"), t); + + dbus_message_unref (reply); + } + else + { + g_print (_("The screensaver is not currently active.\n")); + } + } + + if (do_lock) + { + reply = screensaver_send_message_void (connection, "Lock", FALSE); + } + + if (do_cycle) + { + reply = screensaver_send_message_void (connection, "Cycle", FALSE); + } + + if (do_poke) + { + reply = screensaver_send_message_void (connection, "SimulateUserActivity", FALSE); + } + + if (do_activate) + { + reply = screensaver_send_message_bool (connection, "SetActive", TRUE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_deactivate) + { + reply = screensaver_send_message_bool (connection, "SetActive", FALSE); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + } + + if (do_inhibit) + { + reply = screensaver_send_message_inhibit (connection, + inhibit_application ? inhibit_application : "Unknown", + inhibit_reason ? inhibit_reason : "Unknown"); + if (! reply) + { + g_message ("Did not receive a reply from the screensaver."); + goto done; + } + dbus_message_unref (reply); + + return FALSE; + } + +done: + g_main_loop_quit (loop); + + return FALSE; +} + +int +main (int argc, + char **argv) +{ + DBusConnection *connection; + DBusError dbus_error; + GOptionContext *context; + gboolean retval; + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + g_type_init (); + + g_set_prgname (argv[0]); + + if (setlocale (LC_ALL, "") == NULL) + g_warning ("Locale not understood by C library, internationalization will not work\n"); + + context = g_option_context_new (NULL); + g_option_context_add_main_entries (context, entries, NULL); + retval = g_option_context_parse (context, &argc, &argv, &error); + + g_option_context_free (context); + + if (! retval) + { + g_warning ("%s", error->message); + g_error_free (error); + exit (1); + } + + if (do_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + dbus_error_init (&dbus_error); + connection = dbus_bus_get (DBUS_BUS_SESSION, &dbus_error); + if (! connection) + { + g_message ("Failed to connect to the D-BUS daemon: %s", dbus_error.message); + dbus_error_free (&dbus_error); + exit (1); + } + + dbus_connection_setup_with_g_main (connection, NULL); + + if (! screensaver_is_running (connection)) + { + g_message ("Screensaver is not running!"); + exit (1); + } + + g_idle_add ((GSourceFunc)do_command, connection); + + loop = g_main_loop_new (NULL, FALSE); + g_main_loop_run (loop); + + return 0; +} diff --git a/src/mate-screensaver-dialog.c b/src/mate-screensaver-dialog.c new file mode 100644 index 0000000..d698159 --- /dev/null +++ b/src/mate-screensaver-dialog.c @@ -0,0 +1,665 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-lock-plug.h" + +#include "gs-auth.h" +#include "setuid.h" + +#include "gs-debug.h" + +#define MAX_FAILURES 5 + +static gboolean verbose = FALSE; +static gboolean show_version = FALSE; +static gboolean enable_logout = FALSE; +static gboolean enable_switch = FALSE; +static char *logout_command = NULL; +static char *status_message = NULL; +static char *away_message = NULL; + +static GOptionEntry entries [] = +{ + { + "verbose", 0, 0, G_OPTION_ARG_NONE, &verbose, + N_("Show debugging output"), NULL + }, + { + "version", 0, 0, G_OPTION_ARG_NONE, &show_version, + N_("Version of this application"), NULL + }, + { + "enable-logout", 0, 0, G_OPTION_ARG_NONE, &enable_logout, + N_("Show the logout button"), NULL + }, + { + "logout-command", 0, 0, G_OPTION_ARG_STRING, &logout_command, + N_("Command to invoke from the logout button"), NULL + }, + { + "enable-switch", 0, 0, G_OPTION_ARG_NONE, &enable_switch, + N_("Show the switch user button"), NULL + }, + { + "status-message", 0, 0, G_OPTION_ARG_STRING, &status_message, + N_("Message to show in the dialog"), N_("MESSAGE") + }, + { + "away-message", 0, 0, G_OPTION_ARG_STRING, &away_message, + N_("Not used"), N_("MESSAGE") + }, + { NULL } +}; + +static char * +get_id_string (GtkWidget *widget) +{ + char *id = NULL; + + g_return_val_if_fail (widget != NULL, NULL); + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); + + id = g_strdup_printf ("%" G_GUINT32_FORMAT, + (guint32) GDK_WINDOW_XID (widget->window)); + return id; +} + +static gboolean +print_id (GtkWidget *widget) +{ + char *id; + + gs_profile_start (NULL); + + id = get_id_string (widget); + printf ("WINDOW ID=%s\n", id); + fflush (stdout); + + gs_profile_end (NULL); + + g_free (id); + + return FALSE; +} + +static void +response_cancel (void) +{ + printf ("RESPONSE=CANCEL\n"); + fflush (stdout); +} + +static void +response_ok (void) +{ + printf ("RESPONSE=OK\n"); + fflush (stdout); +} + +static gboolean +quit_response_ok (void) +{ + response_ok (); + gtk_main_quit (); + return FALSE; +} + +static gboolean +quit_response_cancel (void) +{ + response_cancel (); + gtk_main_quit (); + return FALSE; +} + +static void +response_lock_init_failed (void) +{ + /* if we fail to lock then we should drop the dialog */ + response_ok (); +} + +static char * +request_response (GSLockPlug *plug, + const char *prompt, + gboolean visible) +{ + int response; + char *text; + + gs_lock_plug_set_sensitive (plug, TRUE); + gs_lock_plug_enable_prompt (plug, prompt, visible); + response = gs_lock_plug_run (plug); + + gs_debug ("got response: %d", response); + + text = NULL; + if (response == GS_LOCK_PLUG_RESPONSE_OK) + { + gs_lock_plug_get_text (plug, &text); + } + gs_lock_plug_disable_prompt (plug); + + return text; +} + +/* Adapted from MDM2 daemon/verify-pam.c on 2006-06-13 */ +static const char * +maybe_translate_message (const char *msg) +{ + char *s; + const char *ret; + static GHashTable *hash = NULL; + + if (hash == NULL) + { + /* Here we come with some fairly standard messages so that + we have as much as possible translated. Should really be + translated in pam I suppose. This way we can "change" + some of these messages to be more sane. */ + hash = g_hash_table_new (g_str_hash, g_str_equal); + /* login: is whacked always translate to Username: */ + g_hash_table_insert (hash, "login:", _("Username:")); + g_hash_table_insert (hash, "Username:", _("Username:")); + g_hash_table_insert (hash, "username:", _("Username:")); + g_hash_table_insert (hash, "Password:", _("Password:")); + g_hash_table_insert (hash, "password:", _("Password:")); + g_hash_table_insert (hash, "You are required to change your password immediately (password aged)", _("You are required to change your password immediately (password aged)")); + g_hash_table_insert (hash, "You are required to change your password immediately (root enforced)", _("You are required to change your password immediately (root enforced)")); + g_hash_table_insert (hash, "Your account has expired; please contact your system administrator", _("Your account has expired; please contact your system administrator")); + g_hash_table_insert (hash, "No password supplied", _("No password supplied")); + g_hash_table_insert (hash, "Password unchanged", _("Password unchanged")); + g_hash_table_insert (hash, "Can not get username", _("Can not get username")); + g_hash_table_insert (hash, "Retype new UNIX password:", _("Retype new UNIX password:")); + g_hash_table_insert (hash, "Enter new UNIX password:", _("Enter new UNIX password:")); + g_hash_table_insert (hash, "(current) UNIX password:", _("(current) UNIX password:")); + g_hash_table_insert (hash, "Error while changing NIS password.", _("Error while changing NIS password.")); + g_hash_table_insert (hash, "You must choose a longer password", _("You must choose a longer password")); + g_hash_table_insert (hash, "Password has been already used. Choose another.", _("Password has been already used. Choose another.")); + g_hash_table_insert (hash, "You must wait longer to change your password", _("You must wait longer to change your password")); + g_hash_table_insert (hash, "Sorry, passwords do not match", _("Sorry, passwords do not match")); + /* FIXME: what about messages which have some variables in them, perhaps try to do those as well */ + } + + s = g_strstrip (g_strdup (msg)); + ret = g_hash_table_lookup (hash, s); + g_free (s); + + if (ret != NULL) + { + return ret; + } + else + { + return msg; + } +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + GSLockPlug *plug; + const char *message; + + plug = GS_LOCK_PLUG (data); + + gs_profile_start (NULL); + gs_debug ("Got message style %d: '%s'", style, msg); + + gtk_widget_show (GTK_WIDGET (plug)); + gs_lock_plug_set_ready (plug); + + ret = TRUE; + *response = NULL; + message = maybe_translate_message (msg); + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + if (msg != NULL) + { + char *resp; + resp = request_response (plug, message, TRUE); + *response = resp; + } + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + if (msg != NULL) + { + char *resp; + resp = request_response (plug, message, FALSE); + *response = resp; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + gs_lock_plug_show_message (plug, message); + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + gs_lock_plug_show_message (plug, message); + break; + default: + g_assert_not_reached (); + } + + if (*response == NULL) + { + gs_debug ("Got no response"); + ret = FALSE; + } + else + { + gs_lock_plug_show_message (plug, _("Checking...")); + gs_lock_plug_set_sensitive (plug, FALSE); + } + + /* we may have pending events that should be processed before continuing back into PAM */ + while (gtk_events_pending ()) + { + gtk_main_iteration (); + } + + gs_lock_plug_set_busy (plug); + gs_profile_end (NULL); + + return ret; +} + +static gboolean +reset_idle_cb (GSLockPlug *plug) +{ + gs_lock_plug_set_sensitive (plug, TRUE); + gs_lock_plug_show_message (plug, NULL); + + return FALSE; +} + +static gboolean +do_auth_check (GSLockPlug *plug) +{ + GError *error; + gboolean res; + + error = NULL; + + gs_lock_plug_disable_prompt (plug); + gs_lock_plug_set_busy (plug); + res = gs_auth_verify_user (g_get_user_name (), g_getenv ("DISPLAY"), auth_message_handler, plug, &error); + + gs_debug ("Verify user returned: %s", res ? "TRUE" : "FALSE"); + if (! res) + { + if (error != NULL) + { + gs_debug ("Verify user returned error: %s", error->message); + gs_lock_plug_show_message (plug, error->message); + } + else + { + gs_lock_plug_show_message (plug, _("Authentication failed.")); + } + + printf ("NOTICE=AUTH FAILED\n"); + fflush (stdout); + + if (error != NULL) + { + g_error_free (error); + } + } + + return res; +} + +static void +response_cb (GSLockPlug *plug, + gint response_id) +{ + if ((response_id == GS_LOCK_PLUG_RESPONSE_CANCEL) || + (response_id == GTK_RESPONSE_DELETE_EVENT)) + { + quit_response_cancel (); + } +} + +static gboolean +response_request_quit (void) +{ + printf ("REQUEST QUIT\n"); + fflush (stdout); + return FALSE; +} + +static gboolean +quit_timeout_cb (gpointer data) +{ + gtk_main_quit (); + return FALSE; +} + +static gboolean +auth_check_idle (GSLockPlug *plug) +{ + gboolean res; + gboolean again; + static guint loop_counter = 0; + + again = TRUE; + res = do_auth_check (plug); + + if (res) + { + again = FALSE; + g_idle_add ((GSourceFunc)quit_response_ok, NULL); + } + else + { + loop_counter++; + + if (loop_counter < MAX_FAILURES) + { + gs_debug ("Authentication failed, retrying (%u)", loop_counter); + g_timeout_add (3000, (GSourceFunc)reset_idle_cb, plug); + } + else + { + gs_debug ("Authentication failed, quitting (max failures)"); + again = FALSE; + /* Don't quit immediately, but rather request that mate-screensaver + * terminates us after it has finished the dialog shake. Time out + * after 5 seconds and quit anyway if this doesn't happen though */ + g_idle_add ((GSourceFunc)response_request_quit, NULL); + g_timeout_add (5000, (GSourceFunc)quit_timeout_cb, NULL); + } + } + + return again; +} + +static void +show_cb (GtkWidget *widget, + gpointer data) +{ + print_id (widget); +} + +static gboolean +popup_dialog_idle (void) +{ + GtkWidget *widget; + + gs_profile_start (NULL); + + widget = gs_lock_plug_new (); + + if (enable_logout) + { + g_object_set (widget, "logout-enabled", TRUE, NULL); + } + + if (logout_command) + { + g_object_set (widget, "logout-command", logout_command, NULL); + } + + if (enable_switch) + { + g_object_set (widget, "switch-enabled", TRUE, NULL); + } + + if (status_message) + { + g_object_set (widget, "status-message", status_message, NULL); + } + + g_signal_connect (GS_LOCK_PLUG (widget), "response", G_CALLBACK (response_cb), NULL); + g_signal_connect (widget, "show", G_CALLBACK (show_cb), NULL); + + gtk_widget_realize (widget); + + g_idle_add ((GSourceFunc)auth_check_idle, widget); + + gs_profile_end (NULL); + + return FALSE; +} + + +/* + * Copyright (c) 1991-2004 Jamie Zawinski + * Copyright (c) 2005 William Jon McCann + * + * Initializations that potentially take place as a priveleged user: + If the executable is setuid root, then these initializations + are run as root, before discarding privileges. +*/ +static gboolean +privileged_initialization (int *argc, + char **argv, + gboolean verbose) +{ + gboolean ret; + char *nolock_reason; + char *orig_uid; + char *uid_message; + + gs_profile_start (NULL); + +#ifndef NO_LOCKING + /* before hack_uid () for proper permissions */ + gs_auth_priv_init (); +#endif /* NO_LOCKING */ + + ret = hack_uid (&nolock_reason, + &orig_uid, + &uid_message); + + if (nolock_reason) + { + g_debug ("Locking disabled: %s", nolock_reason); + } + + if (uid_message && verbose) + { + g_print ("Modified UID: %s", uid_message); + } + + g_free (nolock_reason); + g_free (orig_uid); + g_free (uid_message); + + gs_profile_end (NULL); + + return ret; +} + + +/* + * Copyright (c) 1991-2004 Jamie Zawinski + * Copyright (c) 2005 William Jon McCann + * + * Figure out what locking mechanisms are supported. + */ +static gboolean +lock_initialization (int *argc, + char **argv, + char **nolock_reason, + gboolean verbose) +{ + if (nolock_reason != NULL) + { + *nolock_reason = NULL; + } + +#ifdef NO_LOCKING + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("not compiled with locking support"); + } + + return FALSE; +#else /* !NO_LOCKING */ + + /* Finish initializing locking, now that we're out of privileged code. */ + if (! gs_auth_init ()) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("error getting password"); + } + + return FALSE; + } + + /* If locking is currently enabled, but the environment indicates that + we have been launched as MDM's "Background" program, then disable + locking just in case. + */ + if (getenv ("RUNNING_UNDER_MDM")) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("running under MDM"); + } + + return FALSE; + } + + /* If the server is XDarwin (MacOS X) then disable locking. + (X grabs only affect X programs, so you can use Command-Tab + to bring any other Mac program to the front, e.g., Terminal.) + */ + { + gboolean macos = FALSE; + +#ifdef __APPLE__ + /* Disable locking if *running* on Apple hardware, since we have no + reliable way to determine whether the server is running on MacOS. + Hopefully __APPLE__ means "MacOS" and not "Linux on Mac hardware" + but I'm not really sure about that. + */ + macos = TRUE; +#endif + + if (macos) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("Cannot lock securely on MacOS X"); + } + + return FALSE; + } + } + +#endif /* NO_LOCKING */ + + return TRUE; +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + char *nolock_reason = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! g_thread_supported ()) + { + g_thread_init (NULL); + } + + g_type_init (); + + gs_profile_start (NULL); + + if (! privileged_initialization (&argc, argv, verbose)) + { + response_lock_init_failed (); + exit (1); + } + + error = NULL; + if (! gtk_init_with_args (&argc, &argv, NULL, entries, NULL, &error)) + { + if (error != NULL) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + } + exit (1); + } + + if (show_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + if (! lock_initialization (&argc, argv, &nolock_reason, verbose)) + { + if (nolock_reason != NULL) + { + g_debug ("Screen locking disabled: %s", nolock_reason); + g_free (nolock_reason); + } + response_lock_init_failed (); + exit (1); + } + + gs_debug_init (verbose, FALSE); + + g_idle_add ((GSourceFunc)popup_dialog_idle, NULL); + + gtk_main (); + + gs_profile_end (NULL); + gs_debug_shutdown (); + + return 0; +} diff --git a/src/mate-screensaver-dialog.c.orig b/src/mate-screensaver-dialog.c.orig new file mode 100644 index 0000000..9c7f143 --- /dev/null +++ b/src/mate-screensaver-dialog.c.orig @@ -0,0 +1,665 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-lock-plug.h" + +#include "gs-auth.h" +#include "setuid.h" + +#include "gs-debug.h" + +#define MAX_FAILURES 5 + +static gboolean verbose = FALSE; +static gboolean show_version = FALSE; +static gboolean enable_logout = FALSE; +static gboolean enable_switch = FALSE; +static char *logout_command = NULL; +static char *status_message = NULL; +static char *away_message = NULL; + +static GOptionEntry entries [] = +{ + { + "verbose", 0, 0, G_OPTION_ARG_NONE, &verbose, + N_("Show debugging output"), NULL + }, + { + "version", 0, 0, G_OPTION_ARG_NONE, &show_version, + N_("Version of this application"), NULL + }, + { + "enable-logout", 0, 0, G_OPTION_ARG_NONE, &enable_logout, + N_("Show the logout button"), NULL + }, + { + "logout-command", 0, 0, G_OPTION_ARG_STRING, &logout_command, + N_("Command to invoke from the logout button"), NULL + }, + { + "enable-switch", 0, 0, G_OPTION_ARG_NONE, &enable_switch, + N_("Show the switch user button"), NULL + }, + { + "status-message", 0, 0, G_OPTION_ARG_STRING, &status_message, + N_("Message to show in the dialog"), N_("MESSAGE") + }, + { + "away-message", 0, 0, G_OPTION_ARG_STRING, &away_message, + N_("Not used"), N_("MESSAGE") + }, + { NULL } +}; + +static char * +get_id_string (GtkWidget *widget) +{ + char *id = NULL; + + g_return_val_if_fail (widget != NULL, NULL); + g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); + + id = g_strdup_printf ("%" G_GUINT32_FORMAT, + (guint32) GDK_WINDOW_XID (widget->window)); + return id; +} + +static gboolean +print_id (GtkWidget *widget) +{ + char *id; + + gs_profile_start (NULL); + + id = get_id_string (widget); + printf ("WINDOW ID=%s\n", id); + fflush (stdout); + + gs_profile_end (NULL); + + g_free (id); + + return FALSE; +} + +static void +response_cancel (void) +{ + printf ("RESPONSE=CANCEL\n"); + fflush (stdout); +} + +static void +response_ok (void) +{ + printf ("RESPONSE=OK\n"); + fflush (stdout); +} + +static gboolean +quit_response_ok (void) +{ + response_ok (); + gtk_main_quit (); + return FALSE; +} + +static gboolean +quit_response_cancel (void) +{ + response_cancel (); + gtk_main_quit (); + return FALSE; +} + +static void +response_lock_init_failed (void) +{ + /* if we fail to lock then we should drop the dialog */ + response_ok (); +} + +static char * +request_response (GSLockPlug *plug, + const char *prompt, + gboolean visible) +{ + int response; + char *text; + + gs_lock_plug_set_sensitive (plug, TRUE); + gs_lock_plug_enable_prompt (plug, prompt, visible); + response = gs_lock_plug_run (plug); + + gs_debug ("got response: %d", response); + + text = NULL; + if (response == GS_LOCK_PLUG_RESPONSE_OK) + { + gs_lock_plug_get_text (plug, &text); + } + gs_lock_plug_disable_prompt (plug); + + return text; +} + +/* Adapted from MDM2 daemon/verify-pam.c on 2006-06-13 */ +static const char * +maybe_translate_message (const char *msg) +{ + char *s; + const char *ret; + static GHashTable *hash = NULL; + + if (hash == NULL) + { + /* Here we come with some fairly standard messages so that + we have as much as possible translated. Should really be + translated in pam I suppose. This way we can "change" + some of these messages to be more sane. */ + hash = g_hash_table_new (g_str_hash, g_str_equal); + /* login: is whacked always translate to Username: */ + g_hash_table_insert (hash, "login:", _("Username:")); + g_hash_table_insert (hash, "Username:", _("Username:")); + g_hash_table_insert (hash, "username:", _("Username:")); + g_hash_table_insert (hash, "Password:", _("Password:")); + g_hash_table_insert (hash, "password:", _("Password:")); + g_hash_table_insert (hash, "You are required to change your password immediately (password aged)", _("You are required to change your password immediately (password aged)")); + g_hash_table_insert (hash, "You are required to change your password immediately (root enforced)", _("You are required to change your password immediately (root enforced)")); + g_hash_table_insert (hash, "Your account has expired; please contact your system administrator", _("Your account has expired; please contact your system administrator")); + g_hash_table_insert (hash, "No password supplied", _("No password supplied")); + g_hash_table_insert (hash, "Password unchanged", _("Password unchanged")); + g_hash_table_insert (hash, "Can not get username", _("Can not get username")); + g_hash_table_insert (hash, "Retype new UNIX password:", _("Retype new UNIX password:")); + g_hash_table_insert (hash, "Enter new UNIX password:", _("Enter new UNIX password:")); + g_hash_table_insert (hash, "(current) UNIX password:", _("(current) UNIX password:")); + g_hash_table_insert (hash, "Error while changing NIS password.", _("Error while changing NIS password.")); + g_hash_table_insert (hash, "You must choose a longer password", _("You must choose a longer password")); + g_hash_table_insert (hash, "Password has been already used. Choose another.", _("Password has been already used. Choose another.")); + g_hash_table_insert (hash, "You must wait longer to change your password", _("You must wait longer to change your password")); + g_hash_table_insert (hash, "Sorry, passwords do not match", _("Sorry, passwords do not match")); + /* FIXME: what about messages which have some variables in them, perhaps try to do those as well */ + } + + s = g_strstrip (g_strdup (msg)); + ret = g_hash_table_lookup (hash, s); + g_free (s); + + if (ret != NULL) + { + return ret; + } + else + { + return msg; + } +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + GSLockPlug *plug; + const char *message; + + plug = GS_LOCK_PLUG (data); + + gs_profile_start (NULL); + gs_debug ("Got message style %d: '%s'", style, msg); + + gtk_widget_show (GTK_WIDGET (plug)); + gs_lock_plug_set_ready (plug); + + ret = TRUE; + *response = NULL; + message = maybe_translate_message (msg); + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + if (msg != NULL) + { + char *resp; + resp = request_response (plug, message, TRUE); + *response = resp; + } + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + if (msg != NULL) + { + char *resp; + resp = request_response (plug, message, FALSE); + *response = resp; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + gs_lock_plug_show_message (plug, message); + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + gs_lock_plug_show_message (plug, message); + break; + default: + g_assert_not_reached (); + } + + if (*response == NULL) + { + gs_debug ("Got no response"); + ret = FALSE; + } + else + { + gs_lock_plug_show_message (plug, _("Checking...")); + gs_lock_plug_set_sensitive (plug, FALSE); + } + + /* we may have pending events that should be processed before continuing back into PAM */ + while (gtk_events_pending ()) + { + gtk_main_iteration (); + } + + gs_lock_plug_set_busy (plug); + gs_profile_end (NULL); + + return ret; +} + +static gboolean +reset_idle_cb (GSLockPlug *plug) +{ + gs_lock_plug_set_sensitive (plug, TRUE); + gs_lock_plug_show_message (plug, NULL); + + return FALSE; +} + +static gboolean +do_auth_check (GSLockPlug *plug) +{ + GError *error; + gboolean res; + + error = NULL; + + gs_lock_plug_disable_prompt (plug); + gs_lock_plug_set_busy (plug); + res = gs_auth_verify_user (g_get_user_name (), g_getenv ("DISPLAY"), auth_message_handler, plug, &error); + + gs_debug ("Verify user returned: %s", res ? "TRUE" : "FALSE"); + if (! res) + { + if (error != NULL) + { + gs_debug ("Verify user returned error: %s", error->message); + gs_lock_plug_show_message (plug, error->message); + } + else + { + gs_lock_plug_show_message (plug, _("Authentication failed.")); + } + + printf ("NOTICE=AUTH FAILED\n"); + fflush (stdout); + + if (error != NULL) + { + g_error_free (error); + } + } + + return res; +} + +static void +response_cb (GSLockPlug *plug, + gint response_id) +{ + if ((response_id == GS_LOCK_PLUG_RESPONSE_CANCEL) || + (response_id == GTK_RESPONSE_DELETE_EVENT)) + { + quit_response_cancel (); + } +} + +static gboolean +response_request_quit (void) +{ + printf ("REQUEST QUIT\n"); + fflush (stdout); + return FALSE; +} + +static gboolean +quit_timeout_cb (gpointer data) +{ + gtk_main_quit (); + return FALSE; +} + +static gboolean +auth_check_idle (GSLockPlug *plug) +{ + gboolean res; + gboolean again; + static guint loop_counter = 0; + + again = TRUE; + res = do_auth_check (plug); + + if (res) + { + again = FALSE; + g_idle_add ((GSourceFunc)quit_response_ok, NULL); + } + else + { + loop_counter++; + + if (loop_counter < MAX_FAILURES) + { + gs_debug ("Authentication failed, retrying (%u)", loop_counter); + g_timeout_add (3000, (GSourceFunc)reset_idle_cb, plug); + } + else + { + gs_debug ("Authentication failed, quitting (max failures)"); + again = FALSE; + /* Don't quit immediately, but rather request that mate-screensaver + * terminates us after it has finished the dialog shake. Time out + * after 5 seconds and quit anyway if this doesn't happen though */ + g_idle_add ((GSourceFunc)response_request_quit, NULL); + g_timeout_add (5000, (GSourceFunc)quit_timeout_cb, NULL); + } + } + + return again; +} + +static void +show_cb (GtkWidget *widget, + gpointer data) +{ + print_id (widget); +} + +static gboolean +popup_dialog_idle (void) +{ + GtkWidget *widget; + + gs_profile_start (NULL); + + widget = gs_lock_plug_new (); + + if (enable_logout) + { + g_object_set (widget, "logout-enabled", TRUE, NULL); + } + + if (logout_command) + { + g_object_set (widget, "logout-command", logout_command, NULL); + } + + if (enable_switch) + { + g_object_set (widget, "switch-enabled", TRUE, NULL); + } + + if (status_message) + { + g_object_set (widget, "status-message", status_message, NULL); + } + + g_signal_connect (GS_LOCK_PLUG (widget), "response", G_CALLBACK (response_cb), NULL); + g_signal_connect (widget, "show", G_CALLBACK (show_cb), NULL); + + gtk_widget_realize (widget); + + g_idle_add ((GSourceFunc)auth_check_idle, widget); + + gs_profile_end (NULL); + + return FALSE; +} + + +/* + * Copyright (c) 1991-2004 Jamie Zawinski + * Copyright (c) 2005 William Jon McCann + * + * Initializations that potentially take place as a priveleged user: + If the executable is setuid root, then these initializations + are run as root, before discarding privileges. +*/ +static gboolean +privileged_initialization (int *argc, + char **argv, + gboolean verbose) +{ + gboolean ret; + char *nolock_reason; + char *orig_uid; + char *uid_message; + + gs_profile_start (NULL); + +#ifndef NO_LOCKING + /* before hack_uid () for proper permissions */ + gs_auth_priv_init (); +#endif /* NO_LOCKING */ + + ret = hack_uid (&nolock_reason, + &orig_uid, + &uid_message); + + if (nolock_reason) + { + g_debug ("Locking disabled: %s", nolock_reason); + } + + if (uid_message && verbose) + { + g_print ("Modified UID: %s", uid_message); + } + + g_free (nolock_reason); + g_free (orig_uid); + g_free (uid_message); + + gs_profile_end (NULL); + + return ret; +} + + +/* + * Copyright (c) 1991-2004 Jamie Zawinski + * Copyright (c) 2005 William Jon McCann + * + * Figure out what locking mechanisms are supported. + */ +static gboolean +lock_initialization (int *argc, + char **argv, + char **nolock_reason, + gboolean verbose) +{ + if (nolock_reason != NULL) + { + *nolock_reason = NULL; + } + +#ifdef NO_LOCKING + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("not compiled with locking support"); + } + + return FALSE; +#else /* !NO_LOCKING */ + + /* Finish initializing locking, now that we're out of privileged code. */ + if (! gs_auth_init ()) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("error getting password"); + } + + return FALSE; + } + + /* If locking is currently enabled, but the environment indicates that + we have been launched as MDM's "Background" program, then disable + locking just in case. + */ + if (getenv ("RUNNING_UNDER_MDM")) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("running under MDM"); + } + + return FALSE; + } + + /* If the server is XDarwin (MacOS X) then disable locking. + (X grabs only affect X programs, so you can use Command-Tab + to bring any other Mac program to the front, e.g., Terminal.) + */ + { + gboolean macos = FALSE; + +#ifdef __APPLE__ + /* Disable locking if *running* on Apple hardware, since we have no + reliable way to determine whether the server is running on MacOS. + Hopefully __APPLE__ means "MacOS" and not "Linux on Mac hardware" + but I'm not really sure about that. + */ + macos = TRUE; +#endif + + if (macos) + { + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup ("Cannot lock securely on MacOS X"); + } + + return FALSE; + } + } + +#endif /* NO_LOCKING */ + + return TRUE; +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + char *nolock_reason = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! g_thread_supported ()) + { + g_thread_init (NULL); + } + + g_type_init (); + + gs_profile_start (NULL); + + if (! privileged_initialization (&argc, argv, verbose)) + { + response_lock_init_failed (); + exit (1); + } + + error = NULL; + if (! gtk_init_with_args (&argc, &argv, NULL, entries, NULL, &error)) + { + if (error != NULL) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + } + exit (1); + } + + if (show_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + if (! lock_initialization (&argc, argv, &nolock_reason, verbose)) + { + if (nolock_reason != NULL) + { + g_debug ("Screen locking disabled: %s", nolock_reason); + g_free (nolock_reason); + } + response_lock_init_failed (); + exit (1); + } + + gs_debug_init (verbose, FALSE); + + g_idle_add ((GSourceFunc)popup_dialog_idle, NULL); + + gtk_main (); + + gs_profile_end (NULL); + gs_debug_shutdown (); + + return 0; +} diff --git a/src/mate-screensaver-gl-helper.c b/src/mate-screensaver-gl-helper.c new file mode 100644 index 0000000..fd128f5 --- /dev/null +++ b/src/mate-screensaver-gl-helper.c @@ -0,0 +1,83 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include + +#include "gs-visual-gl.h" + +int +main (int argc, + char **argv) +{ + GdkDisplay *display; + GdkScreen *screen; + GdkVisual *visual; + Visual *xvisual; + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + g_type_init (); + + g_set_prgname (argv[0]); + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + if (error != NULL) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to initialize GTK+"); + } + exit (1); + } + + display = gdk_display_get_default (); + screen = gdk_display_get_default_screen (display); + visual = gs_visual_gl_get_best_for_screen (screen); + + if (visual != NULL) + { + xvisual = gdk_x11_visual_get_xvisual (visual); + printf ("0x%x\n", (unsigned int) XVisualIDFromVisual (xvisual)); + } + else + { + printf ("none\n"); + } + + return 0; +} diff --git a/src/mate-screensaver-gl-helper.c.orig b/src/mate-screensaver-gl-helper.c.orig new file mode 100644 index 0000000..70b56e4 --- /dev/null +++ b/src/mate-screensaver-gl-helper.c.orig @@ -0,0 +1,83 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2006 William Jon McCann + * + * 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. + * + */ + +#include "config.h" + +#include +#include +#include + +#include +#include + +#include "gs-visual-gl.h" + +int +main (int argc, + char **argv) +{ + GdkDisplay *display; + GdkScreen *screen; + GdkVisual *visual; + Visual *xvisual; + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + g_type_init (); + + g_set_prgname (argv[0]); + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + if (error != NULL) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to initialize GTK+"); + } + exit (1); + } + + display = gdk_display_get_default (); + screen = gdk_display_get_default_screen (display); + visual = gs_visual_gl_get_best_for_screen (screen); + + if (visual != NULL) + { + xvisual = gdk_x11_visual_get_xvisual (visual); + printf ("0x%x\n", (unsigned int) XVisualIDFromVisual (xvisual)); + } + else + { + printf ("none\n"); + } + + return 0; +} diff --git a/src/mate-screensaver-preferences.c b/src/mate-screensaver-preferences.c new file mode 100644 index 0000000..5bcf5e5 --- /dev/null +++ b/src/mate-screensaver-preferences.c @@ -0,0 +1,1781 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * Rodrigo Moya + * + */ + +#include "config.h" + +#define _GNU_SOURCE +#include +#include +#include +#include /* For uid_t, gid_t */ + +#include +#include +#include +#include + +#include + +#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 ("%s", 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; +} 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 + * + * 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 + * Rodrigo Moya + * + */ + +#include "config.h" + +#define _GNU_SOURCE +#include +#include +#include +#include /* For uid_t, gid_t */ + +#include +#include +#include +#include + +#include + +#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 ("%s", 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; +} diff --git a/src/mate-screensaver.c b/src/mate-screensaver.c new file mode 100644 index 0000000..1e76fe6 --- /dev/null +++ b/src/mate-screensaver.c @@ -0,0 +1,132 @@ +/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 8; tab-width: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "mate-screensaver.h" +#include "gs-monitor.h" +#include "gs-debug.h" + +void +mate_screensaver_quit (void) +{ + gtk_main_quit (); +} + +int +main (int argc, + char **argv) +{ + GSMonitor *monitor; + GError *error = NULL; + static gboolean show_version = FALSE; + static gboolean no_daemon = FALSE; + static gboolean debug = FALSE; + static GOptionEntry entries [] = + { + { "version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL }, + { "no-daemon", 0, 0, G_OPTION_ARG_NONE, &no_daemon, N_("Don't become a daemon"), NULL }, + { "debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL }, + { NULL } + }; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, entries, NULL, &error)) + { + if (error) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to initialize GTK+"); + } + exit (1); + } + + if (show_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + /* debug to a file if in deamon mode */ + gs_debug_init (debug, ! no_daemon); + gs_debug ("initializing mate-screensaver %s", VERSION); + + monitor = gs_monitor_new (); + + if (monitor == NULL) + { + exit (1); + } + + error = NULL; + if (! gs_monitor_start (monitor, &error)) + { + if (error) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to start screensaver"); + } + exit (1); + } + + /* Don't close stdout and stderr for now */ + if (! no_daemon && daemon (0, 1)) + { + g_error ("Could not daemonize: %s", g_strerror (errno)); + } + + gtk_main (); + + g_object_unref (monitor); + + gs_debug ("mate-screensaver finished"); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/mate-screensaver.c.orig b/src/mate-screensaver.c.orig new file mode 100644 index 0000000..456d377 --- /dev/null +++ b/src/mate-screensaver.c.orig @@ -0,0 +1,132 @@ +/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 8; tab-width: 8 -*- + * + * Copyright (C) 2004-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "mate-screensaver.h" +#include "gs-monitor.h" +#include "gs-debug.h" + +void +mate_screensaver_quit (void) +{ + gtk_main_quit (); +} + +int +main (int argc, + char **argv) +{ + GSMonitor *monitor; + GError *error = NULL; + static gboolean show_version = FALSE; + static gboolean no_daemon = FALSE; + static gboolean debug = FALSE; + static GOptionEntry entries [] = + { + { "version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_("Version of this application"), NULL }, + { "no-daemon", 0, 0, G_OPTION_ARG_NONE, &no_daemon, N_("Don't become a daemon"), NULL }, + { "debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable debugging code"), NULL }, + { NULL } + }; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, entries, NULL, &error)) + { + if (error) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to initialize GTK+"); + } + exit (1); + } + + if (show_version) + { + g_print ("%s %s\n", argv [0], VERSION); + exit (1); + } + + /* debug to a file if in deamon mode */ + gs_debug_init (debug, ! no_daemon); + gs_debug ("initializing mate-screensaver %s", VERSION); + + monitor = gs_monitor_new (); + + if (monitor == NULL) + { + exit (1); + } + + error = NULL; + if (! gs_monitor_start (monitor, &error)) + { + if (error) + { + g_warning ("%s", error->message); + g_error_free (error); + } + else + { + g_warning ("Unable to start screensaver"); + } + exit (1); + } + + /* Don't close stdout and stderr for now */ + if (! no_daemon && daemon (0, 1)) + { + g_error ("Could not daemonize: %s", g_strerror (errno)); + } + + gtk_main (); + + g_object_unref (monitor); + + gs_debug ("mate-screensaver finished"); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/mate-screensaver.desktop.in.in b/src/mate-screensaver.desktop.in.in new file mode 100644 index 0000000..8aaeb18 --- /dev/null +++ b/src/mate-screensaver.desktop.in.in @@ -0,0 +1,14 @@ +[Desktop Entry] +Type=Application +_Name=Screensaver +_Comment=Launch screen saver and locker program +Icon=preferences-desktop-screensaver +Exec=mate-screensaver +OnlyShowIn=MATE; +NoDisplay=true +X-MATE-Autostart-Phase=Application +X-MATE-Autostart-Notify=true +X-MATE-Bugzilla-Bugzilla=MATE +X-MATE-Bugzilla-Product=mate-screensaver +X-MATE-Bugzilla-Component=general +X-MATE-Bugzilla-Version=@VERSION@ diff --git a/src/mate-screensaver.h b/src/mate-screensaver.h new file mode 100644 index 0000000..34b3a7c --- /dev/null +++ b/src/mate-screensaver.h @@ -0,0 +1,32 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2004-2005 William Jon McCann + * + * 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 + * + */ + +#ifndef __MATE_SCREENSAVER_H +#define __MATE_SCREENSAVER_H + +G_BEGIN_DECLS + +void mate_screensaver_quit (void); + +G_END_DECLS + +#endif diff --git a/src/setuid.c b/src/setuid.c new file mode 100644 index 0000000..80e4659 --- /dev/null +++ b/src/setuid.c @@ -0,0 +1,247 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * setuid.c --- management of runtime privileges. + * + * xscreensaver, Copyright (c) 1993-1998 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#include "config.h" + +#ifndef EPERM +#include +#endif + +#include +#include +#include +#include +#include /* for getpwnam() and struct passwd */ +#include /* for getgrgid() and struct group */ +#include + +#include "setuid.h" + +static char * +uid_gid_string (uid_t uid, + gid_t gid) +{ + static char *buf; + struct passwd *p = NULL; + struct group *g = NULL; + + p = getpwuid (uid); + g = getgrgid (gid); + + buf = g_strdup_printf ("%s/%s (%ld/%ld)", + (p && p->pw_name ? p->pw_name : "???"), + (g && g->gr_name ? g->gr_name : "???"), + (long) uid, (long) gid); + + return buf; +} + +static gboolean +set_ids_by_number (uid_t uid, + gid_t gid, + char **message_ret) +{ + int uid_errno = 0; + int gid_errno = 0; + int sgs_errno = 0; + struct passwd *p = getpwuid (uid); + struct group *g = getgrgid (gid); + + if (message_ret) + *message_ret = NULL; + + /* Rumor has it that some implementations of of setuid() do nothing + when called with -1; therefore, if the "nobody" user has a uid of + -1, then that would be Really Bad. Rumor further has it that such + systems really ought to be using -2 for "nobody", since that works. + So, if we get a uid (or gid, for good measure) of -1, switch to -2 + instead. Note that this must be done after we've looked up the + user/group names with getpwuid(-1) and/or getgrgid(-1). + */ + if (gid == (gid_t) -1) gid = (gid_t) -2; + if (uid == (uid_t) -1) uid = (uid_t) -2; + + errno = 0; + if (setgroups (1, &gid) < 0) + sgs_errno = errno ? errno : -1; + + errno = 0; + if (setgid (gid) != 0) + gid_errno = errno ? errno : -1; + + errno = 0; + if (setuid (uid) != 0) + uid_errno = errno ? errno : -1; + + if (uid_errno == 0 && gid_errno == 0 && sgs_errno == 0) + { + static char *reason; + reason = g_strdup_printf ("changed uid/gid to %s/%s (%ld/%ld).", + (p && p->pw_name ? p->pw_name : "???"), + (g && g->gr_name ? g->gr_name : "???"), + (long) uid, (long) gid); + if (message_ret) + *message_ret = g_strdup (reason); + + g_free (reason); + + return TRUE; + } + else + { + char *reason = NULL; + + if (sgs_errno) + { + reason = g_strdup_printf ("couldn't setgroups to %s (%ld)", + (g && g->gr_name ? g->gr_name : "???"), + (long) gid); + if (sgs_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = sgs_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + + if (gid_errno) + { + reason = g_strdup_printf ("couldn't set gid to %s (%ld)", + (g && g->gr_name ? g->gr_name : "???"), + (long) gid); + if (gid_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = gid_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + + if (uid_errno) + { + reason = g_strdup_printf ("couldn't set uid to %s (%ld)", + (p && p->pw_name ? p->pw_name : "???"), + (long) uid); + if (uid_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = uid_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + return FALSE; + } + return FALSE; +} + + +/* If we've been run as setuid or setgid to someone else (most likely root) + turn off the extra permissions so that random user-specified programs + don't get special privileges. (On some systems it is necessary to install + this program as setuid root in order to read the passwd file to implement + lock-mode.) + + *** WARNING: DO NOT DISABLE ANY OF THE FOLLOWING CODE! + If you do so, you will open a security hole. See the sections + of the xscreensaver manual titled "LOCKING AND ROOT LOGINS", + and "USING XDM". +*/ + +/* Returns TRUE if OK to lock, FALSE otherwise */ +gboolean +hack_uid (char **nolock_reason, + char **orig_uid, + char **uid_message) +{ + char *reason; + gboolean ret; + + ret = TRUE; + reason = NULL; + + if (nolock_reason != NULL) + { + *nolock_reason = NULL; + } + if (orig_uid != NULL) + { + *orig_uid = NULL; + } + if (uid_message != NULL) + { + *uid_message = NULL; + } + + /* Discard privileges, and set the effective user/group ids to the + real user/group ids. That is, give up our "chmod +s" rights. + */ + { + uid_t euid = geteuid (); + gid_t egid = getegid (); + uid_t uid = getuid (); + gid_t gid = getgid (); + + if (orig_uid != NULL) + { + *orig_uid = uid_gid_string (euid, egid); + } + + if (uid != euid || gid != egid) + { + if (! set_ids_by_number (uid, gid, uid_message)) + { + reason = g_strdup ("unable to discard privileges."); + + ret = FALSE; + goto out; + } + } + } + + + /* Locking can't work when running as root, because we have no way of + knowing what the user id of the logged in user is (so we don't know + whose password to prompt for.) + + *** WARNING: DO NOT DISABLE THIS CODE! + If you do so, you will open a security hole. See the sections + of the xscreensaver manual titled "LOCKING AND ROOT LOGINS", + and "USING XDM". + */ + if (getuid () == (uid_t) 0) + { + reason = g_strdup ("running as root"); + ret = FALSE; + goto out; + } + +out: + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup (reason); + } + g_free (reason); + + return ret; +} diff --git a/src/setuid.c.orig b/src/setuid.c.orig new file mode 100644 index 0000000..2c55c2e --- /dev/null +++ b/src/setuid.c.orig @@ -0,0 +1,247 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * setuid.c --- management of runtime privileges. + * + * xscreensaver, Copyright (c) 1993-1998 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#include "config.h" + +#ifndef EPERM +#include +#endif + +#include +#include +#include +#include +#include /* for getpwnam() and struct passwd */ +#include /* for getgrgid() and struct group */ +#include + +#include "setuid.h" + +static char * +uid_gid_string (uid_t uid, + gid_t gid) +{ + static char *buf; + struct passwd *p = NULL; + struct group *g = NULL; + + p = getpwuid (uid); + g = getgrgid (gid); + + buf = g_strdup_printf ("%s/%s (%ld/%ld)", + (p && p->pw_name ? p->pw_name : "???"), + (g && g->gr_name ? g->gr_name : "???"), + (long) uid, (long) gid); + + return buf; +} + +static gboolean +set_ids_by_number (uid_t uid, + gid_t gid, + char **message_ret) +{ + int uid_errno = 0; + int gid_errno = 0; + int sgs_errno = 0; + struct passwd *p = getpwuid (uid); + struct group *g = getgrgid (gid); + + if (message_ret) + *message_ret = NULL; + + /* Rumor has it that some implementations of of setuid() do nothing + when called with -1; therefore, if the "nobody" user has a uid of + -1, then that would be Really Bad. Rumor further has it that such + systems really ought to be using -2 for "nobody", since that works. + So, if we get a uid (or gid, for good measure) of -1, switch to -2 + instead. Note that this must be done after we've looked up the + user/group names with getpwuid(-1) and/or getgrgid(-1). + */ + if (gid == (gid_t) -1) gid = (gid_t) -2; + if (uid == (uid_t) -1) uid = (uid_t) -2; + + errno = 0; + if (setgroups (1, &gid) < 0) + sgs_errno = errno ? errno : -1; + + errno = 0; + if (setgid (gid) != 0) + gid_errno = errno ? errno : -1; + + errno = 0; + if (setuid (uid) != 0) + uid_errno = errno ? errno : -1; + + if (uid_errno == 0 && gid_errno == 0 && sgs_errno == 0) + { + static char *reason; + reason = g_strdup_printf ("changed uid/gid to %s/%s (%ld/%ld).", + (p && p->pw_name ? p->pw_name : "???"), + (g && g->gr_name ? g->gr_name : "???"), + (long) uid, (long) gid); + if (message_ret) + *message_ret = g_strdup (reason); + + g_free (reason); + + return TRUE; + } + else + { + char *reason = NULL; + + if (sgs_errno) + { + reason = g_strdup_printf ("couldn't setgroups to %s (%ld)", + (g && g->gr_name ? g->gr_name : "???"), + (long) gid); + if (sgs_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = sgs_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + + if (gid_errno) + { + reason = g_strdup_printf ("couldn't set gid to %s (%ld)", + (g && g->gr_name ? g->gr_name : "???"), + (long) gid); + if (gid_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = gid_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + + if (uid_errno) + { + reason = g_strdup_printf ("couldn't set uid to %s (%ld)", + (p && p->pw_name ? p->pw_name : "???"), + (long) uid); + if (uid_errno == -1) + fprintf (stderr, "%s: unknown error\n", reason); + else + { + errno = uid_errno; + perror (reason); + } + g_free (reason); + reason = NULL; + } + return FALSE; + } + return FALSE; +} + + +/* If we've been run as setuid or setgid to someone else (most likely root) + turn off the extra permissions so that random user-specified programs + don't get special privileges. (On some systems it is necessary to install + this program as setuid root in order to read the passwd file to implement + lock-mode.) + + *** WARNING: DO NOT DISABLE ANY OF THE FOLLOWING CODE! + If you do so, you will open a security hole. See the sections + of the xscreensaver manual titled "LOCKING AND ROOT LOGINS", + and "USING XDM". +*/ + +/* Returns TRUE if OK to lock, FALSE otherwise */ +gboolean +hack_uid (char **nolock_reason, + char **orig_uid, + char **uid_message) +{ + char *reason; + gboolean ret; + + ret = TRUE; + reason = NULL; + + if (nolock_reason != NULL) + { + *nolock_reason = NULL; + } + if (orig_uid != NULL) + { + *orig_uid = NULL; + } + if (uid_message != NULL) + { + *uid_message = NULL; + } + + /* Discard privileges, and set the effective user/group ids to the + real user/group ids. That is, give up our "chmod +s" rights. + */ + { + uid_t euid = geteuid (); + gid_t egid = getegid (); + uid_t uid = getuid (); + gid_t gid = getgid (); + + if (orig_uid != NULL) + { + *orig_uid = uid_gid_string (euid, egid); + } + + if (uid != euid || gid != egid) + { + if (! set_ids_by_number (uid, gid, uid_message)) + { + reason = g_strdup ("unable to discard privileges."); + + ret = FALSE; + goto out; + } + } + } + + + /* Locking can't work when running as root, because we have no way of + knowing what the user id of the logged in user is (so we don't know + whose password to prompt for.) + + *** WARNING: DO NOT DISABLE THIS CODE! + If you do so, you will open a security hole. See the sections + of the xscreensaver manual titled "LOCKING AND ROOT LOGINS", + and "USING XDM". + */ + if (getuid () == (uid_t) 0) + { + reason = g_strdup ("running as root"); + ret = FALSE; + goto out; + } + +out: + if (nolock_reason != NULL) + { + *nolock_reason = g_strdup (reason); + } + g_free (reason); + + return ret; +} diff --git a/src/setuid.h b/src/setuid.h new file mode 100644 index 0000000..ffb490d --- /dev/null +++ b/src/setuid.h @@ -0,0 +1,25 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * xscreensaver, Copyright (c) 1993-2004 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#ifndef __GS_SETUID_H +#define __GS_SETUID_H + +G_BEGIN_DECLS + +gboolean hack_uid (char **nolock_reason, + char **orig_uid, + char **uid_message); + +G_END_DECLS + +#endif /* __GS_SETUID_H */ diff --git a/src/setuid.h.orig b/src/setuid.h.orig new file mode 100644 index 0000000..8cb8808 --- /dev/null +++ b/src/setuid.h.orig @@ -0,0 +1,25 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * xscreensaver, Copyright (c) 1993-2004 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#ifndef __GS_SETUID_H +#define __GS_SETUID_H + +G_BEGIN_DECLS + +gboolean hack_uid (char **nolock_reason, + char **orig_uid, + char **uid_message); + +G_END_DECLS + +#endif /* __GS_SETUID_H */ diff --git a/src/subprocs.c b/src/subprocs.c new file mode 100644 index 0000000..757daf8 --- /dev/null +++ b/src/subprocs.c @@ -0,0 +1,166 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * subprocs.c --- choosing, spawning, and killing screenhacks. + * + * xscreensaver, Copyright (c) 1991-2003 Jamie Zawinski + * Modified: Copyright (c) 2004 William Jon McCann + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#include "config.h" + +#include +#include +#include +#include + +#ifndef ESRCH +# include +#endif + +#include /* sys/resource.h needs this for timeval */ +# include /* for waitpid() and associated macros */ + +#ifdef VMS +# include +# include /* for close */ +# include /* for getpid */ +# define pid_t int +# define fork vfork +#endif /* VMS */ + +#include /* for the signal names */ + +#include +#include "subprocs.h" + +#if !defined(SIGCHLD) && defined(SIGCLD) +# define SIGCHLD SIGCLD +#endif + +/* Semaphore to temporarily turn the SIGCHLD handler into a no-op. + Don't alter this directly -- use block_sigchld() / unblock_sigchld(). +*/ +static int block_sigchld_handler = 0; + + +#ifdef HAVE_SIGACTION +sigset_t +#else /* !HAVE_SIGACTION */ +int +#endif /* !HAVE_SIGACTION */ +block_sigchld (void) +{ +#ifdef HAVE_SIGACTION + sigset_t child_set; + sigemptyset (&child_set); + sigaddset (&child_set, SIGCHLD); + sigaddset (&child_set, SIGPIPE); + sigprocmask (SIG_BLOCK, &child_set, 0); +#endif /* HAVE_SIGACTION */ + + block_sigchld_handler++; + +#ifdef HAVE_SIGACTION + return child_set; +#else /* !HAVE_SIGACTION */ + return 0; +#endif /* !HAVE_SIGACTION */ +} + +void +unblock_sigchld (void) +{ +#ifdef HAVE_SIGACTION + sigset_t child_set; + sigemptyset (&child_set); + sigaddset (&child_set, SIGCHLD); + sigaddset (&child_set, SIGPIPE); + sigprocmask (SIG_UNBLOCK, &child_set, 0); +#endif /* HAVE_SIGACTION */ + + block_sigchld_handler--; +} + +int +signal_pid (int pid, + int signal) +{ + int status = -1; + gboolean verbose = TRUE; + + if (block_sigchld_handler) + /* This function should not be called from the signal handler. */ + abort(); + + block_sigchld (); /* we control the horizontal... */ + + status = kill (pid, signal); + + if (verbose && status < 0) + { + if (errno == ESRCH) + g_message ("Child process %lu was already dead.", + (unsigned long) pid); + else + { + char buf [1024]; + snprintf (buf, sizeof (buf), "Couldn't kill child process %lu", + (unsigned long) pid); + perror (buf); + } + } + + unblock_sigchld (); + + if (block_sigchld_handler < 0) + abort (); + + return status; +} + +#ifndef VMS + +void +await_dying_children (int pid, + gboolean debug) +{ + while (1) + { + int wait_status = 0; + pid_t kid; + + errno = 0; + kid = waitpid (-1, &wait_status, WNOHANG|WUNTRACED); + + if (debug) + { + if (kid < 0 && errno) + g_message ("waitpid(%d) ==> %ld (%d)", pid, (long) kid, errno); + else if (kid != 0) + g_message ("waitpid(%d) ==> %ld", pid, (long) kid); + } + + /* 0 means no more children to reap. + -1 means error -- except "interrupted system call" isn't a "real" + error, so if we get that, we should just try again. */ + if (kid < 0 && errno != EINTR) + break; + } +} + + +#else /* VMS */ +static void await_dying_children (saver_info *si) +{ + return; +} +#endif /* VMS */ + diff --git a/src/subprocs.c.orig b/src/subprocs.c.orig new file mode 100644 index 0000000..3c18e08 --- /dev/null +++ b/src/subprocs.c.orig @@ -0,0 +1,166 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * subprocs.c --- choosing, spawning, and killing screenhacks. + * + * xscreensaver, Copyright (c) 1991-2003 Jamie Zawinski + * Modified: Copyright (c) 2004 William Jon McCann + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#include "config.h" + +#include +#include +#include +#include + +#ifndef ESRCH +# include +#endif + +#include /* sys/resource.h needs this for timeval */ +# include /* for waitpid() and associated macros */ + +#ifdef VMS +# include +# include /* for close */ +# include /* for getpid */ +# define pid_t int +# define fork vfork +#endif /* VMS */ + +#include /* for the signal names */ + +#include +#include "subprocs.h" + +#if !defined(SIGCHLD) && defined(SIGCLD) +# define SIGCHLD SIGCLD +#endif + +/* Semaphore to temporarily turn the SIGCHLD handler into a no-op. + Don't alter this directly -- use block_sigchld() / unblock_sigchld(). +*/ +static int block_sigchld_handler = 0; + + +#ifdef HAVE_SIGACTION +sigset_t +#else /* !HAVE_SIGACTION */ +int +#endif /* !HAVE_SIGACTION */ +block_sigchld (void) +{ +#ifdef HAVE_SIGACTION + sigset_t child_set; + sigemptyset (&child_set); + sigaddset (&child_set, SIGCHLD); + sigaddset (&child_set, SIGPIPE); + sigprocmask (SIG_BLOCK, &child_set, 0); +#endif /* HAVE_SIGACTION */ + + block_sigchld_handler++; + +#ifdef HAVE_SIGACTION + return child_set; +#else /* !HAVE_SIGACTION */ + return 0; +#endif /* !HAVE_SIGACTION */ +} + +void +unblock_sigchld (void) +{ +#ifdef HAVE_SIGACTION + sigset_t child_set; + sigemptyset (&child_set); + sigaddset (&child_set, SIGCHLD); + sigaddset (&child_set, SIGPIPE); + sigprocmask (SIG_UNBLOCK, &child_set, 0); +#endif /* HAVE_SIGACTION */ + + block_sigchld_handler--; +} + +int +signal_pid (int pid, + int signal) +{ + int status = -1; + gboolean verbose = TRUE; + + if (block_sigchld_handler) + /* This function should not be called from the signal handler. */ + abort(); + + block_sigchld (); /* we control the horizontal... */ + + status = kill (pid, signal); + + if (verbose && status < 0) + { + if (errno == ESRCH) + g_message ("Child process %lu was already dead.", + (unsigned long) pid); + else + { + char buf [1024]; + snprintf (buf, sizeof (buf), "Couldn't kill child process %lu", + (unsigned long) pid); + perror (buf); + } + } + + unblock_sigchld (); + + if (block_sigchld_handler < 0) + abort (); + + return status; +} + +#ifndef VMS + +void +await_dying_children (int pid, + gboolean debug) +{ + while (1) + { + int wait_status = 0; + pid_t kid; + + errno = 0; + kid = waitpid (-1, &wait_status, WNOHANG|WUNTRACED); + + if (debug) + { + if (kid < 0 && errno) + g_message ("waitpid(%d) ==> %ld (%d)", pid, (long) kid, errno); + else if (kid != 0) + g_message ("waitpid(%d) ==> %ld", pid, (long) kid); + } + + /* 0 means no more children to reap. + -1 means error -- except "interrupted system call" isn't a "real" + error, so if we get that, we should just try again. */ + if (kid < 0 && errno != EINTR) + break; + } +} + + +#else /* VMS */ +static void await_dying_children (saver_info *si) +{ + return; +} +#endif /* VMS */ + diff --git a/src/subprocs.h b/src/subprocs.h new file mode 100644 index 0000000..95744cd --- /dev/null +++ b/src/subprocs.h @@ -0,0 +1,39 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * subprocs.c --- choosing, spawning, and killing screenhacks. + * + * xscreensaver, Copyright (c) 1991-2003 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#ifndef __GS_SUBPROCS_H +#define __GS_SUBPROCS_H + +#include + +G_BEGIN_DECLS + +void unblock_sigchld (void); + +#ifdef HAVE_SIGACTION +sigset_t +#else /* !HAVE_SIGACTION */ +int +#endif /* !HAVE_SIGACTION */ +block_sigchld (void); + +int signal_pid (int pid, + int signal); +void await_dying_children (int pid, + gboolean debug); + +G_END_DECLS + +#endif /* __GS_SUBPROCS_H */ diff --git a/src/subprocs.h.orig b/src/subprocs.h.orig new file mode 100644 index 0000000..30fec7b --- /dev/null +++ b/src/subprocs.h.orig @@ -0,0 +1,39 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * subprocs.c --- choosing, spawning, and killing screenhacks. + * + * xscreensaver, Copyright (c) 1991-2003 Jamie Zawinski + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +#ifndef __GS_SUBPROCS_H +#define __GS_SUBPROCS_H + +#include + +G_BEGIN_DECLS + +void unblock_sigchld (void); + +#ifdef HAVE_SIGACTION +sigset_t +#else /* !HAVE_SIGACTION */ +int +#endif /* !HAVE_SIGACTION */ +block_sigchld (void); + +int signal_pid (int pid, + int signal); +void await_dying_children (int pid, + gboolean debug); + +G_END_DECLS + +#endif /* __GS_SUBPROCS_H */ diff --git a/src/test-fade.c b/src/test-fade.c new file mode 100644 index 0000000..2bc6c92 --- /dev/null +++ b/src/test-fade.c @@ -0,0 +1,134 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-fade.h" +#include "gs-debug.h" + +#ifdef HAVE_XF86VMODE_GAMMA +# include +#endif + +#define XF86_VIDMODE_NAME "XFree86-VidModeExtension" + +static void +test_fade (void) +{ + GSFade *fade; + int reps = 2; + int delay = 2; + + fade = gs_fade_new (); + + while (reps-- > 0) + { + + g_print ("fading out..."); + gs_fade_sync (fade, 1000); + g_print ("done.\n"); + + g_print ("fading in..."); + gs_fade_reset (fade); + g_print ("done.\n"); + + if (delay) + { + sleep (delay); + } + } + + g_object_unref (fade); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + int op, event, err; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (error) + { + fprintf (stderr, "%s\n", error->message); + exit (1); + } + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + if (! XQueryExtension (GDK_DISPLAY (), XF86_VIDMODE_NAME, &op, &event, &err)) + { + g_message ("no " XF86_VIDMODE_NAME " extension"); + } + else + { +# ifdef HAVE_XF86VMODE_GAMMA + int major; + int minor; + + if (! XF86VidModeQueryVersion (GDK_DISPLAY (), &major, &minor)) + { + g_message ("unable to get " XF86_VIDMODE_NAME " version"); + } + else + { + g_message (XF86_VIDMODE_NAME " version %d.%d", major, minor); + } +# else /* !HAVE_XF86VMODE_GAMMA */ + g_message ("no support for display's " XF86_VIDMODE_NAME " extension"); +# endif /* !HAVE_XF86VMODE_GAMMA */ + } + + gs_debug_init (TRUE, FALSE); + + test_fade (); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/test-fade.c.orig b/src/test-fade.c.orig new file mode 100644 index 0000000..894085c --- /dev/null +++ b/src/test-fade.c.orig @@ -0,0 +1,134 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "gs-fade.h" +#include "gs-debug.h" + +#ifdef HAVE_XF86VMODE_GAMMA +# include +#endif + +#define XF86_VIDMODE_NAME "XFree86-VidModeExtension" + +static void +test_fade (void) +{ + GSFade *fade; + int reps = 2; + int delay = 2; + + fade = gs_fade_new (); + + while (reps-- > 0) + { + + g_print ("fading out..."); + gs_fade_sync (fade, 1000); + g_print ("done.\n"); + + g_print ("fading in..."); + gs_fade_reset (fade); + g_print ("done.\n"); + + if (delay) + { + sleep (delay); + } + } + + g_object_unref (fade); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + int op, event, err; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (error) + { + fprintf (stderr, "%s\n", error->message); + exit (1); + } + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + if (! XQueryExtension (GDK_DISPLAY (), XF86_VIDMODE_NAME, &op, &event, &err)) + { + g_message ("no " XF86_VIDMODE_NAME " extension"); + } + else + { +# ifdef HAVE_XF86VMODE_GAMMA + int major; + int minor; + + if (! XF86VidModeQueryVersion (GDK_DISPLAY (), &major, &minor)) + { + g_message ("unable to get " XF86_VIDMODE_NAME " version"); + } + else + { + g_message (XF86_VIDMODE_NAME " version %d.%d", major, minor); + } +# else /* !HAVE_XF86VMODE_GAMMA */ + g_message ("no support for display's " XF86_VIDMODE_NAME " extension"); +# endif /* !HAVE_XF86VMODE_GAMMA */ + } + + gs_debug_init (TRUE, FALSE); + + test_fade (); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/test-passwd.c b/src/test-passwd.c new file mode 100644 index 0000000..3f7a849 --- /dev/null +++ b/src/test-passwd.c @@ -0,0 +1,288 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-auth.h" +#include "setuid.h" + +/* Initializations that potentially take place as a priveleged user: + If the executable is setuid root, then these initializations + are run as root, before discarding privileges. +*/ +static gboolean +privileged_initialization (void) +{ + gboolean ret; + char *nolock_reason; + char *orig_uid; + char *uid_message; + +#ifndef NO_LOCKING + /* before hack_uid () for proper permissions */ + gs_auth_priv_init (); +#endif /* NO_LOCKING */ + + ret = hack_uid (&nolock_reason, + &orig_uid, + &uid_message); + if (nolock_reason) + { + g_warning ("Locking disabled: %s", nolock_reason); + } + if (uid_message && gs_auth_get_verbose ()) + { + g_print ("Modified UID: %s", uid_message); + } + + g_free (nolock_reason); + g_free (orig_uid); + g_free (uid_message); + + return ret; +} + + +/* Figure out what locking mechanisms are supported. + */ +static gboolean +lock_initialization (char **nolock_reason) +{ + if (nolock_reason) + { + *nolock_reason = NULL; + } + +#ifdef NO_LOCKING + if (nolock_reason) + { + *nolock_reason = g_strdup ("not compiled with locking support"); + } + return FALSE; +#else /* !NO_LOCKING */ + + /* Finish initializing locking, now that we're out of privileged code. */ + if (! gs_auth_init ()) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("error getting password"); + } + return FALSE; + } + + /* If locking is currently enabled, but the environment indicates that + we have been launched as MDM's "Background" program, then disable + locking just in case. + */ + if (getenv ("RUNNING_UNDER_MDM")) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("running under MDM"); + } + return FALSE; + } + + /* If the server is XDarwin (MacOS X) then disable locking. + (X grabs only affect X programs, so you can use Command-Tab + to bring any other Mac program to the front, e.g., Terminal.) + */ + { + gboolean macos = FALSE; + +#ifdef __APPLE__ + /* Disable locking if *running* on Apple hardware, since we have no + reliable way to determine whether the server is running on MacOS. + Hopefully __APPLE__ means "MacOS" and not "Linux on Mac hardware" + but I'm not really sure about that. + */ + macos = TRUE; +#endif + + if (macos) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("Cannot lock securely on MacOS X"); + } + return FALSE; + } + } + +#endif /* NO_LOCKING */ + + return TRUE; +} + +static char * +request_password (const char *prompt) +{ + char buf [255]; + char *pass; + char *password; + struct termios ts0; + struct termios ts1; + + tcgetattr (fileno (stdin), &ts0); + ts1 = ts0; + ts1.c_lflag &= ~ECHO; + + printf ("%s", prompt); + + if (tcsetattr (fileno (stdin), TCSAFLUSH, &ts1) != 0) + { + fprintf (stderr, "Could not set terminal attributes\n"); + exit (1); + } + + pass = fgets (buf, sizeof (buf) - 1, stdin); + + tcsetattr (fileno (stdin), TCSANOW, &ts0); + + if (!pass || !*pass) + { + exit (0); + } + + if (pass [strlen (pass) - 1] == '\n') + { + pass [strlen (pass) - 1] = 0; + } + + password = g_strdup (pass); + + memset (pass, '\b', strlen (pass)); + + return password; +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + + g_message ("Got message style %d: '%s'", style, msg); + + ret = TRUE; + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + { + char *password; + password = request_password (msg); + *response = password; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + break; + default: + g_assert_not_reached (); + } + + return ret; +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + gboolean verbose = TRUE; + char *nolock_reason = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! g_thread_supported ()) + { + g_thread_init (NULL); + } + + gs_auth_set_verbose (verbose); + if (! privileged_initialization ()) + { + exit (1); + } + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + if (! lock_initialization (&nolock_reason)) + { + if (nolock_reason) + { + g_warning ("Screen locking disabled: %s", nolock_reason); + g_free (nolock_reason); + } + + exit (1); + } + +again: + error = NULL; + + if (gs_auth_verify_user (g_get_user_name (), g_getenv ("DISPLAY"), auth_message_handler, NULL, &error)) + { + printf ("Correct!\n"); + } + else + { + if (error != NULL) + { + fprintf (stderr, "ERROR: %s\n", error->message); + g_error_free (error); + } + printf ("Incorrect\n"); + goto again; + } + + return 0; +} diff --git a/src/test-passwd.c.orig b/src/test-passwd.c.orig new file mode 100644 index 0000000..70bccce --- /dev/null +++ b/src/test-passwd.c.orig @@ -0,0 +1,288 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005-2006 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "gs-auth.h" +#include "setuid.h" + +/* Initializations that potentially take place as a priveleged user: + If the executable is setuid root, then these initializations + are run as root, before discarding privileges. +*/ +static gboolean +privileged_initialization (void) +{ + gboolean ret; + char *nolock_reason; + char *orig_uid; + char *uid_message; + +#ifndef NO_LOCKING + /* before hack_uid () for proper permissions */ + gs_auth_priv_init (); +#endif /* NO_LOCKING */ + + ret = hack_uid (&nolock_reason, + &orig_uid, + &uid_message); + if (nolock_reason) + { + g_warning ("Locking disabled: %s", nolock_reason); + } + if (uid_message && gs_auth_get_verbose ()) + { + g_print ("Modified UID: %s", uid_message); + } + + g_free (nolock_reason); + g_free (orig_uid); + g_free (uid_message); + + return ret; +} + + +/* Figure out what locking mechanisms are supported. + */ +static gboolean +lock_initialization (char **nolock_reason) +{ + if (nolock_reason) + { + *nolock_reason = NULL; + } + +#ifdef NO_LOCKING + if (nolock_reason) + { + *nolock_reason = g_strdup ("not compiled with locking support"); + } + return FALSE; +#else /* !NO_LOCKING */ + + /* Finish initializing locking, now that we're out of privileged code. */ + if (! gs_auth_init ()) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("error getting password"); + } + return FALSE; + } + + /* If locking is currently enabled, but the environment indicates that + we have been launched as MDM's "Background" program, then disable + locking just in case. + */ + if (getenv ("RUNNING_UNDER_MDM")) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("running under MDM"); + } + return FALSE; + } + + /* If the server is XDarwin (MacOS X) then disable locking. + (X grabs only affect X programs, so you can use Command-Tab + to bring any other Mac program to the front, e.g., Terminal.) + */ + { + gboolean macos = FALSE; + +#ifdef __APPLE__ + /* Disable locking if *running* on Apple hardware, since we have no + reliable way to determine whether the server is running on MacOS. + Hopefully __APPLE__ means "MacOS" and not "Linux on Mac hardware" + but I'm not really sure about that. + */ + macos = TRUE; +#endif + + if (macos) + { + if (nolock_reason) + { + *nolock_reason = g_strdup ("Cannot lock securely on MacOS X"); + } + return FALSE; + } + } + +#endif /* NO_LOCKING */ + + return TRUE; +} + +static char * +request_password (const char *prompt) +{ + char buf [255]; + char *pass; + char *password; + struct termios ts0; + struct termios ts1; + + tcgetattr (fileno (stdin), &ts0); + ts1 = ts0; + ts1.c_lflag &= ~ECHO; + + printf ("%s", prompt); + + if (tcsetattr (fileno (stdin), TCSAFLUSH, &ts1) != 0) + { + fprintf (stderr, "Could not set terminal attributes\n"); + exit (1); + } + + pass = fgets (buf, sizeof (buf) - 1, stdin); + + tcsetattr (fileno (stdin), TCSANOW, &ts0); + + if (!pass || !*pass) + { + exit (0); + } + + if (pass [strlen (pass) - 1] == '\n') + { + pass [strlen (pass) - 1] = 0; + } + + password = g_strdup (pass); + + memset (pass, '\b', strlen (pass)); + + return password; +} + +static gboolean +auth_message_handler (GSAuthMessageStyle style, + const char *msg, + char **response, + gpointer data) +{ + gboolean ret; + + g_message ("Got message style %d: '%s'", style, msg); + + ret = TRUE; + + switch (style) + { + case GS_AUTH_MESSAGE_PROMPT_ECHO_ON: + break; + case GS_AUTH_MESSAGE_PROMPT_ECHO_OFF: + { + char *password; + password = request_password (msg); + *response = password; + } + break; + case GS_AUTH_MESSAGE_ERROR_MSG: + break; + case GS_AUTH_MESSAGE_TEXT_INFO: + break; + default: + g_assert_not_reached (); + } + + return ret; +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + gboolean verbose = TRUE; + char *nolock_reason = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! g_thread_supported ()) + { + g_thread_init (NULL); + } + + gs_auth_set_verbose (verbose); + if (! privileged_initialization ()) + { + exit (1); + } + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + if (! lock_initialization (&nolock_reason)) + { + if (nolock_reason) + { + g_warning ("Screen locking disabled: %s", nolock_reason); + g_free (nolock_reason); + } + + exit (1); + } + +again: + error = NULL; + + if (gs_auth_verify_user (g_get_user_name (), g_getenv ("DISPLAY"), auth_message_handler, NULL, &error)) + { + printf ("Correct!\n"); + } + else + { + if (error != NULL) + { + fprintf (stderr, "ERROR: %s\n", error->message); + g_error_free (error); + } + printf ("Incorrect\n"); + goto again; + } + + return 0; +} diff --git a/src/test-watcher.c b/src/test-watcher.c new file mode 100644 index 0000000..5e8ca08 --- /dev/null +++ b/src/test-watcher.c @@ -0,0 +1,106 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include + +#include "gs-watcher.h" +#include "gs-debug.h" + +static gboolean +watcher_idle_cb (GSWatcher *watcher, + gboolean is_idle, + gpointer data) +{ + g_message ("Idle status changed: %s", is_idle ? "idle" : "not idle"); + + /* return FALSE so that the idle watcher continues */ + return FALSE; +} + +static gboolean +watcher_idle_notice_cb (GSWatcher *watcher, + gboolean is_idle, + gpointer data) +{ + g_message ("Idle notice status changed: %s", is_idle ? "idle" : "not idle"); + + return TRUE; +} + +static void +connect_watcher_signals (GSWatcher *watcher) +{ + g_signal_connect (watcher, "idle-changed", + G_CALLBACK (watcher_idle_cb), NULL); + g_signal_connect (watcher, "idle-notice-changed", + G_CALLBACK (watcher_idle_notice_cb), NULL); +} + +static void +test_watcher (void) +{ + GSWatcher *watcher; + + watcher = gs_watcher_new (); + gs_watcher_set_enabled (watcher, TRUE); + gs_watcher_set_active (watcher, TRUE); + + connect_watcher_signals (watcher); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + gs_debug_init (TRUE, FALSE); + + test_watcher (); + + gtk_main (); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/test-watcher.c.orig b/src/test-watcher.c.orig new file mode 100644 index 0000000..28c7678 --- /dev/null +++ b/src/test-watcher.c.orig @@ -0,0 +1,106 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include + +#include "gs-watcher.h" +#include "gs-debug.h" + +static gboolean +watcher_idle_cb (GSWatcher *watcher, + gboolean is_idle, + gpointer data) +{ + g_message ("Idle status changed: %s", is_idle ? "idle" : "not idle"); + + /* return FALSE so that the idle watcher continues */ + return FALSE; +} + +static gboolean +watcher_idle_notice_cb (GSWatcher *watcher, + gboolean is_idle, + gpointer data) +{ + g_message ("Idle notice status changed: %s", is_idle ? "idle" : "not idle"); + + return TRUE; +} + +static void +connect_watcher_signals (GSWatcher *watcher) +{ + g_signal_connect (watcher, "idle-changed", + G_CALLBACK (watcher_idle_cb), NULL); + g_signal_connect (watcher, "idle-notice-changed", + G_CALLBACK (watcher_idle_notice_cb), NULL); +} + +static void +test_watcher (void) +{ + GSWatcher *watcher; + + watcher = gs_watcher_new (); + gs_watcher_set_enabled (watcher, TRUE); + gs_watcher_set_active (watcher, TRUE); + + connect_watcher_signals (watcher); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + gs_debug_init (TRUE, FALSE); + + test_watcher (); + + gtk_main (); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/test-window.c b/src/test-window.c new file mode 100644 index 0000000..6600411 --- /dev/null +++ b/src/test-window.c @@ -0,0 +1,180 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include + +#include "gs-window.h" +#include "gs-grab.h" +#include "gs-debug.h" + +static GSGrab *grab = NULL; + +static void +window_deactivated_cb (GSWindow *window, + gpointer data) +{ + gs_window_destroy (window); +} + +static void +window_dialog_up_cb (GSWindow *window, + gpointer data) +{ +} + +static void +window_dialog_down_cb (GSWindow *window, + gpointer data) +{ +} + +static void +window_show_cb (GSWindow *window, + gpointer data) +{ + /* Grab keyboard so dialog can be used */ + gs_grab_move_to_window (grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + +} + +static gboolean +window_activity_cb (GSWindow *window, + gpointer data) +{ + gs_window_request_unlock (window); + + return TRUE; +} + +static void +disconnect_window_signals (GSWindow *window) +{ + gpointer data; + + data = NULL; + g_signal_handlers_disconnect_by_func (window, window_activity_cb, data); + g_signal_handlers_disconnect_by_func (window, window_deactivated_cb, data); + g_signal_handlers_disconnect_by_func (window, window_dialog_up_cb, data); + g_signal_handlers_disconnect_by_func (window, window_dialog_down_cb, data); + g_signal_handlers_disconnect_by_func (window, window_show_cb, data); +} + +static void +window_destroyed_cb (GtkWindow *window, + gpointer data) +{ + disconnect_window_signals (GS_WINDOW (window)); + gs_grab_release (grab); + gtk_main_quit (); +} + +static void +connect_window_signals (GSWindow *window) +{ + gpointer data; + + data = NULL; + + g_signal_connect_object (window, "activity", + G_CALLBACK (window_activity_cb), data, 0); + g_signal_connect_object (window, "destroy", + G_CALLBACK (window_destroyed_cb), data, 0); + g_signal_connect_object (window, "deactivated", + G_CALLBACK (window_deactivated_cb), data, 0); + g_signal_connect_object (window, "dialog-up", + G_CALLBACK (window_dialog_up_cb), data, 0); + g_signal_connect_object (window, "dialog-down", + G_CALLBACK (window_dialog_down_cb), data, 0); + g_signal_connect_object (window, "show", + G_CALLBACK (window_show_cb), data, 0); +} + +static void +test_window (void) +{ + GSWindow *window; + gboolean lock_active; + gboolean user_switch_enabled; + GdkScreen *screen; + int monitor; + + lock_active = TRUE; + user_switch_enabled = TRUE; + screen = gdk_screen_get_default (); + monitor = 0; + + window = gs_window_new (screen, monitor, lock_active); + + gs_window_set_user_switch_enabled (window, user_switch_enabled); + + connect_window_signals (window); + + gs_window_show (window); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + gs_debug_init (TRUE, FALSE); + + grab = gs_grab_new (); + + test_window (); + + /* safety valve in case we can't authenticate */ + g_timeout_add (30000, (GSourceFunc)gtk_main_quit, NULL); + + gtk_main (); + + g_object_unref (grab); + + gs_debug_shutdown (); + + return 0; +} diff --git a/src/test-window.c.orig b/src/test-window.c.orig new file mode 100644 index 0000000..bc4d37b --- /dev/null +++ b/src/test-window.c.orig @@ -0,0 +1,180 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2005 William Jon McCann + * + * 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 + * + */ + +#include "config.h" + +#include + +#include +#include + +#include "gs-window.h" +#include "gs-grab.h" +#include "gs-debug.h" + +static GSGrab *grab = NULL; + +static void +window_deactivated_cb (GSWindow *window, + gpointer data) +{ + gs_window_destroy (window); +} + +static void +window_dialog_up_cb (GSWindow *window, + gpointer data) +{ +} + +static void +window_dialog_down_cb (GSWindow *window, + gpointer data) +{ +} + +static void +window_show_cb (GSWindow *window, + gpointer data) +{ + /* Grab keyboard so dialog can be used */ + gs_grab_move_to_window (grab, + gs_window_get_gdk_window (window), + gs_window_get_screen (window), + FALSE); + +} + +static gboolean +window_activity_cb (GSWindow *window, + gpointer data) +{ + gs_window_request_unlock (window); + + return TRUE; +} + +static void +disconnect_window_signals (GSWindow *window) +{ + gpointer data; + + data = NULL; + g_signal_handlers_disconnect_by_func (window, window_activity_cb, data); + g_signal_handlers_disconnect_by_func (window, window_deactivated_cb, data); + g_signal_handlers_disconnect_by_func (window, window_dialog_up_cb, data); + g_signal_handlers_disconnect_by_func (window, window_dialog_down_cb, data); + g_signal_handlers_disconnect_by_func (window, window_show_cb, data); +} + +static void +window_destroyed_cb (GtkWindow *window, + gpointer data) +{ + disconnect_window_signals (GS_WINDOW (window)); + gs_grab_release (grab); + gtk_main_quit (); +} + +static void +connect_window_signals (GSWindow *window) +{ + gpointer data; + + data = NULL; + + g_signal_connect_object (window, "activity", + G_CALLBACK (window_activity_cb), data, 0); + g_signal_connect_object (window, "destroy", + G_CALLBACK (window_destroyed_cb), data, 0); + g_signal_connect_object (window, "deactivated", + G_CALLBACK (window_deactivated_cb), data, 0); + g_signal_connect_object (window, "dialog-up", + G_CALLBACK (window_dialog_up_cb), data, 0); + g_signal_connect_object (window, "dialog-down", + G_CALLBACK (window_dialog_down_cb), data, 0); + g_signal_connect_object (window, "show", + G_CALLBACK (window_show_cb), data, 0); +} + +static void +test_window (void) +{ + GSWindow *window; + gboolean lock_active; + gboolean user_switch_enabled; + GdkScreen *screen; + int monitor; + + lock_active = TRUE; + user_switch_enabled = TRUE; + screen = gdk_screen_get_default (); + monitor = 0; + + window = gs_window_new (screen, monitor, lock_active); + + gs_window_set_user_switch_enabled (window, user_switch_enabled); + + connect_window_signals (window); + + gs_window_show (window); +} + +int +main (int argc, + char **argv) +{ + GError *error = NULL; + +#ifdef ENABLE_NLS + bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); +# ifdef HAVE_BIND_TEXTDOMAIN_CODESET + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +# endif + textdomain (GETTEXT_PACKAGE); +#endif + + if (! gtk_init_with_args (&argc, &argv, NULL, NULL, NULL, &error)) + { + fprintf (stderr, "%s", error->message); + g_error_free (error); + exit (1); + } + + gs_debug_init (TRUE, FALSE); + + grab = gs_grab_new (); + + test_window (); + + /* safety valve in case we can't authenticate */ + g_timeout_add (30000, (GSourceFunc)gtk_main_quit, NULL); + + gtk_main (); + + g_object_unref (grab); + + gs_debug_shutdown (); + + return 0; +} -- cgit v1.2.1