1 files changed, 1164 insertions, 0 deletions
diff --git a/mate-session/gsm-inhibit-dialog.c b/mate-session/gsm-inhibit-dialog.c
new file mode 100644
index 0000000..d5b4d57
--- /dev/null
+++ b/mate-session/gsm-inhibit-dialog.c
@@ -0,0 +1,1164 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2008 William Jon McCann <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+
+#include <mateconf/mateconf-client.h>
+
+#include "gsm-inhibit-dialog.h"
+#include "gsm-store.h"
+#include "gsm-client.h"
+#include "gsm-inhibitor.h"
+#include "eggdesktopfile.h"
+#include "gsm-util.h"
+
+#ifdef HAVE_XRENDER
+#include <X11/extensions/Xrender.h>
+#endif
+
+#define GSM_INHIBIT_DIALOG_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSM_TYPE_INHIBIT_DIALOG, GsmInhibitDialogPrivate))
+
+#define IS_STRING_EMPTY(x) ((x)==NULL||(x)[0]=='\0')
+
+#define GTKBUILDER_FILE "gsm-inhibit-dialog.ui"
+
+#ifndef DEFAULT_ICON_SIZE
+#define DEFAULT_ICON_SIZE 32
+#endif
+
+#ifndef DEFAULT_SNAPSHOT_SIZE
+#define DEFAULT_SNAPSHOT_SIZE 128
+#endif
+
+#define DIALOG_RESPONSE_LOCK_SCREEN 1
+
+struct GsmInhibitDialogPrivate
+{
+ GtkBuilder *xml;
+ int action;
+ gboolean is_done;
+ GsmStore *inhibitors;
+ GsmStore *clients;
+ GtkListStore *list_store;
+ gboolean have_xrender;
+ int xrender_event_base;
+ int xrender_error_base;
+};
+
+enum {
+ PROP_0,
+ PROP_ACTION,
+ PROP_INHIBITOR_STORE,
+ PROP_CLIENT_STORE
+};
+
+enum {
+ INHIBIT_IMAGE_COLUMN = 0,
+ INHIBIT_NAME_COLUMN,
+ INHIBIT_REASON_COLUMN,
+ INHIBIT_ID_COLUMN,
+ NUMBER_OF_COLUMNS
+};
+
+static void gsm_inhibit_dialog_class_init (GsmInhibitDialogClass *klass);
+static void gsm_inhibit_dialog_init (GsmInhibitDialog *inhibit_dialog);
+static void gsm_inhibit_dialog_finalize (GObject *object);
+
+G_DEFINE_TYPE (GsmInhibitDialog, gsm_inhibit_dialog, GTK_TYPE_DIALOG)
+
+static void
+lock_screen (GsmInhibitDialog *dialog)
+{
+ GError *error;
+ error = NULL;
+ g_spawn_command_line_async ("mate-screensaver-command --lock", &error);
+ if (error != NULL) {
+ g_warning ("Couldn't lock screen: %s", error->message);
+ g_error_free (error);
+ }
+}
+
+static void
+on_response (GsmInhibitDialog *dialog,
+ gint response_id)
+
+{
+ if (dialog->priv->is_done) {
+ g_signal_stop_emission_by_name (dialog, "response");
+ return;
+ }
+
+ switch (response_id) {
+ case DIALOG_RESPONSE_LOCK_SCREEN:
+ g_signal_stop_emission_by_name (dialog, "response");
+ lock_screen (dialog);
+ break;
+ default:
+ dialog->priv->is_done = TRUE;
+ break;
+ }
+}
+
+static void
+gsm_inhibit_dialog_set_action (GsmInhibitDialog *dialog,
+ int action)
+{
+ dialog->priv->action = action;
+}
+
+static gboolean
+find_inhibitor (GsmInhibitDialog *dialog,
+ const char *id,
+ GtkTreeIter *iter)
+{
+ GtkTreeModel *model;
+ gboolean found_item;
+
+ g_assert (GSM_IS_INHIBIT_DIALOG (dialog));
+
+ found_item = FALSE;
+ model = GTK_TREE_MODEL (dialog->priv->list_store);
+
+ if (!gtk_tree_model_get_iter_first (model, iter)) {
+ return FALSE;
+ }
+
+ do {
+ char *item_id;
+
+ gtk_tree_model_get (model,
+ iter,
+ INHIBIT_ID_COLUMN, &item_id,
+ -1);
+ if (item_id != NULL
+ && id != NULL
+ && strcmp (item_id, id) == 0) {
+ found_item = TRUE;
+ }
+ g_free (item_id);
+ } while (!found_item && gtk_tree_model_iter_next (model, iter));
+
+ return found_item;
+}
+
+/* copied from mate-panel panel-util.c */
+static char *
+_util_icon_remove_extension (const char *icon)
+{
+ char *icon_no_extension;
+ char *p;
+
+ icon_no_extension = g_strdup (icon);
+ p = strrchr (icon_no_extension, '.');
+ if (p &&
+ (strcmp (p, ".png") == 0 ||
+ strcmp (p, ".xpm") == 0 ||
+ strcmp (p, ".svg") == 0)) {
+ *p = 0;
+ }
+
+ return icon_no_extension;
+}
+
+/* copied from mate-panel panel-util.c */
+static char *
+_find_icon (GtkIconTheme *icon_theme,
+ const char *icon_name,
+ gint size)
+{
+ GtkIconInfo *info;
+ char *retval;
+ char *icon_no_extension;
+
+ if (icon_name == NULL || strcmp (icon_name, "") == 0)
+ return NULL;
+
+ if (g_path_is_absolute (icon_name)) {
+ if (g_file_test (icon_name, G_FILE_TEST_EXISTS)) {
+ return g_strdup (icon_name);
+ } else {
+ char *basename;
+
+ basename = g_path_get_basename (icon_name);
+ retval = _find_icon (icon_theme, basename,
+ size);
+ g_free (basename);
+
+ return retval;
+ }
+ }
+
+ /* This is needed because some .desktop files have an icon name *and*
+ * an extension as icon */
+ icon_no_extension = _util_icon_remove_extension (icon_name);
+
+ info = gtk_icon_theme_lookup_icon (icon_theme, icon_no_extension,
+ size, 0);
+
+ g_free (icon_no_extension);
+
+ if (info) {
+ retval = g_strdup (gtk_icon_info_get_filename (info));
+ gtk_icon_info_free (info);
+ } else
+ retval = NULL;
+
+ return retval;
+}
+
+/* copied from mate-panel panel-util.c */
+static GdkPixbuf *
+_load_icon (GtkIconTheme *icon_theme,
+ const char *icon_name,
+ int size,
+ int desired_width,
+ int desired_height,
+ char **error_msg)
+{
+ GdkPixbuf *retval;
+ char *file;
+ GError *error;
+
+ g_return_val_if_fail (error_msg == NULL || *error_msg == NULL, NULL);
+
+ file = _find_icon (icon_theme, icon_name, size);
+ if (!file) {
+ if (error_msg)
+ *error_msg = g_strdup_printf (_("Icon '%s' not found"),
+ icon_name);
+
+ return NULL;
+ }
+
+ error = NULL;
+ retval = gdk_pixbuf_new_from_file_at_size (file,
+ desired_width,
+ desired_height,
+ &error);
+ if (error) {
+ if (error_msg)
+ *error_msg = g_strdup (error->message);
+ g_error_free (error);
+ }
+
+ g_free (file);
+
+ return retval;
+}
+
+
+static GdkPixbuf *
+scale_pixbuf (GdkPixbuf *pixbuf,
+ int max_width,
+ int max_height,
+ gboolean no_stretch_hint)
+{
+ int pw;
+ int ph;
+ float scale_factor_x = 1.0;
+ float scale_factor_y = 1.0;
+ float scale_factor = 1.0;
+
+ pw = gdk_pixbuf_get_width (pixbuf);
+ ph = gdk_pixbuf_get_height (pixbuf);
+
+ /* Determine which dimension requires the smallest scale. */
+ scale_factor_x = (float) max_width / (float) pw;
+ scale_factor_y = (float) max_height / (float) ph;
+
+ if (scale_factor_x > scale_factor_y) {
+ scale_factor = scale_factor_y;
+ } else {
+ scale_factor = scale_factor_x;
+ }
+
+ /* always scale down, allow to disable scaling up */
+ if (scale_factor < 1.0 || !no_stretch_hint) {
+ int scale_x = (int) (pw * scale_factor);
+ int scale_y = (int) (ph * scale_factor);
+ g_debug ("Scaling to %dx%d", scale_x, scale_y);
+ return gdk_pixbuf_scale_simple (pixbuf,
+ scale_x,
+ scale_y,
+ GDK_INTERP_BILINEAR);
+ } else {
+ return g_object_ref (pixbuf);
+ }
+}
+
+#ifdef HAVE_XRENDER
+
+/* adapted from marco */
+static GdkColormap*
+get_cmap (GdkPixmap *pixmap)
+{
+ GdkColormap *cmap;
+
+ cmap = gdk_drawable_get_colormap (pixmap);
+ if (cmap) {
+ g_object_ref (G_OBJECT (cmap));
+ }
+
+ if (cmap == NULL) {
+ if (gdk_drawable_get_depth (pixmap) == 1) {
+ g_debug ("Using NULL colormap for snapshotting bitmap\n");
+ cmap = NULL;
+ } else {
+ g_debug ("Using system cmap to snapshot pixmap\n");
+ cmap = gdk_screen_get_system_colormap (gdk_drawable_get_screen (pixmap));
+
+ g_object_ref (G_OBJECT (cmap));
+ }
+ }
+
+ /* Be sure we aren't going to blow up due to visual mismatch */
+ if (cmap &&
+ (gdk_visual_get_depth (gdk_colormap_get_visual (cmap)) !=
+ gdk_drawable_get_depth (pixmap))) {
+ cmap = NULL;
+ g_debug ("Switching back to NULL cmap because of depth mismatch\n");
+ }
+
+ return cmap;
+}
+
+static GdkPixbuf *
+pixbuf_get_from_pixmap (Pixmap xpixmap)
+{
+ GdkDrawable *drawable;
+ GdkPixbuf *retval;
+ GdkColormap *cmap;
+ int width;
+ int height;
+
+ retval = NULL;
+ cmap = NULL;
+
+ g_debug ("GsmInhibitDialog: getting foreign pixmap for %u", (guint)xpixmap);
+ drawable = gdk_pixmap_foreign_new (xpixmap);
+ if (GDK_IS_PIXMAP (drawable)) {
+ cmap = get_cmap (drawable);
+
+ #if GTK_CHECK_VERSION(3, 0, 0)
+ width = gdk_window_get_width(drawable);
+ height = gdk_window_get_height(drawable);
+ #else
+ gdk_drawable_get_size(drawable, &width, &height);
+ #endif
+
+ g_debug ("GsmInhibitDialog: getting pixbuf w=%d h=%d", width, height);
+
+ retval = gdk_pixbuf_get_from_drawable (NULL,
+ drawable,
+ cmap,
+ 0, 0,
+ 0, 0,
+ width, height);
+ }
+ if (cmap) {
+ g_object_unref (G_OBJECT (cmap));
+ }
+ if (drawable) {
+ g_object_unref (G_OBJECT (drawable));
+ }
+
+ return retval;
+}
+
+static Pixmap
+get_pixmap_for_window (Window window)
+{
+ XWindowAttributes attr;
+ XRenderPictureAttributes pa;
+ Pixmap pixmap;
+ XRenderPictFormat *format;
+ Picture src_picture;
+ Picture dst_picture;
+ gboolean has_alpha;
+ int x;
+ int y;
+ int width;
+ int height;
+
+ XGetWindowAttributes (GDK_DISPLAY (), window, &attr);
+
+ format = XRenderFindVisualFormat (GDK_DISPLAY (), attr.visual);
+ has_alpha = (format->type == PictTypeDirect && format->direct.alphaMask);
+ x = attr.x;
+ y = attr.y;
+ width = attr.width;
+ height = attr.height;
+
+ pa.subwindow_mode = IncludeInferiors; /* Don't clip child widgets */
+
+ src_picture = XRenderCreatePicture (GDK_DISPLAY (), window, format, CPSubwindowMode, &pa);
+
+ pixmap = XCreatePixmap (GDK_DISPLAY (),
+ window,
+ width, height,
+ attr.depth);
+
+ dst_picture = XRenderCreatePicture (GDK_DISPLAY (), pixmap, format, 0, 0);
+ XRenderComposite (GDK_DISPLAY (),
+ has_alpha ? PictOpOver : PictOpSrc,
+ src_picture,
+ None,
+ dst_picture,
+ 0, 0, 0, 0,
+ 0, 0,
+ width, height);
+
+
+ return pixmap;
+}
+
+#endif /* HAVE_COMPOSITE */
+
+static GdkPixbuf *
+get_pixbuf_for_window (guint xid,
+ int width,
+ int height)
+{
+ GdkPixbuf *pixbuf = NULL;
+#ifdef HAVE_XRENDER
+ Window xwindow;
+ Pixmap xpixmap;
+
+ xwindow = (Window) xid;
+ xpixmap = get_pixmap_for_window (xwindow);
+ if (xpixmap == None) {
+ g_debug ("GsmInhibitDialog: Unable to get window snapshot for %u", xid);
+ return NULL;
+ } else {
+ g_debug ("GsmInhibitDialog: Got xpixmap %u", (guint)xpixmap);
+ }
+
+ pixbuf = pixbuf_get_from_pixmap (xpixmap);
+
+ if (xpixmap != None) {
+ gdk_error_trap_push ();
+ XFreePixmap (GDK_DISPLAY (), xpixmap);
+ gdk_display_sync (gdk_display_get_default ());
+ gdk_error_trap_pop ();
+ }
+
+ if (pixbuf != NULL) {
+ GdkPixbuf *scaled;
+ g_debug ("GsmInhibitDialog: scaling pixbuf to w=%d h=%d", width, height);
+ scaled = scale_pixbuf (pixbuf, width, height, TRUE);
+ g_object_unref (pixbuf);
+ pixbuf = scaled;
+ }
+#else
+ g_debug ("GsmInhibitDialog: no support for getting window snapshot");
+#endif
+ return pixbuf;
+}
+
+static void
+add_inhibitor (GsmInhibitDialog *dialog,
+ GsmInhibitor *inhibitor)
+{
+ const char *name;
+ const char *icon_name;
+ const char *app_id;
+ char *desktop_filename;
+ GdkPixbuf *pixbuf;
+ EggDesktopFile *desktop_file;
+ GError *error;
+ char **search_dirs;
+ guint xid;
+ char *freeme;
+
+ /* FIXME: get info from xid */
+
+ desktop_file = NULL;
+ name = NULL;
+ pixbuf = NULL;
+ freeme = NULL;
+
+ app_id = gsm_inhibitor_peek_app_id (inhibitor);
+
+ if (IS_STRING_EMPTY (app_id)) {
+ desktop_filename = NULL;
+ } else if (! g_str_has_suffix (app_id, ".desktop")) {
+ desktop_filename = g_strdup_printf ("%s.desktop", app_id);
+ } else {
+ desktop_filename = g_strdup (app_id);
+ }
+
+ xid = gsm_inhibitor_peek_toplevel_xid (inhibitor);
+ g_debug ("GsmInhibitDialog: inhibitor has XID %u", xid);
+ if (xid > 0 && dialog->priv->have_xrender) {
+ pixbuf = get_pixbuf_for_window (xid, DEFAULT_SNAPSHOT_SIZE, DEFAULT_SNAPSHOT_SIZE);
+ if (pixbuf == NULL) {
+ g_debug ("GsmInhibitDialog: unable to read pixbuf from %u", xid);
+ }
+ }
+
+ if (desktop_filename != NULL) {
+ search_dirs = gsm_util_get_desktop_dirs ();
+
+ if (g_path_is_absolute (desktop_filename)) {
+ char *basename;
+
+ error = NULL;
+ desktop_file = egg_desktop_file_new (desktop_filename,
+ &error);
+ if (desktop_file == NULL) {
+ if (error) {
+ g_warning ("Unable to load desktop file '%s': %s",
+ desktop_filename, error->message);
+ g_error_free (error);
+ } else {
+ g_warning ("Unable to load desktop file '%s'",
+ desktop_filename);
+ }
+
+ basename = g_path_get_basename (desktop_filename);
+ g_free (desktop_filename);
+ desktop_filename = basename;
+ }
+ }
+
+ if (desktop_file == NULL) {
+ error = NULL;
+ desktop_file = egg_desktop_file_new_from_dirs (desktop_filename,
+ (const char **)search_dirs,
+ &error);
+ }
+
+ /* look for a file with a vendor prefix */
+ if (desktop_file == NULL) {
+ if (error) {
+ g_warning ("Unable to find desktop file '%s': %s",
+ desktop_filename, error->message);
+ g_error_free (error);
+ } else {
+ g_warning ("Unable to find desktop file '%s'",
+ desktop_filename);
+ }
+ g_free (desktop_filename);
+ desktop_filename = g_strdup_printf ("mate-%s.desktop", app_id);
+ error = NULL;
+ desktop_file = egg_desktop_file_new_from_dirs (desktop_filename,
+ (const char **)search_dirs,
+ &error);
+ }
+ g_strfreev (search_dirs);
+
+ if (desktop_file == NULL) {
+ if (error) {
+ g_warning ("Unable to find desktop file '%s': %s",
+ desktop_filename, error->message);
+ g_error_free (error);
+ } else {
+ g_warning ("Unable to find desktop file '%s'",
+ desktop_filename);
+ }
+ } else {
+ name = egg_desktop_file_get_name (desktop_file);
+ icon_name = egg_desktop_file_get_icon (desktop_file);
+
+ if (pixbuf == NULL) {
+ pixbuf = _load_icon (gtk_icon_theme_get_default (),
+ icon_name,
+ DEFAULT_ICON_SIZE,
+ DEFAULT_ICON_SIZE,
+ DEFAULT_ICON_SIZE,
+ NULL);
+ }
+ }
+ }
+
+ /* try client info */
+ if (name == NULL) {
+ const char *client_id;
+ client_id = gsm_inhibitor_peek_client_id (inhibitor);
+ if (! IS_STRING_EMPTY (client_id)) {
+ GsmClient *client;
+ client = GSM_CLIENT (gsm_store_lookup (dialog->priv->clients, client_id));
+ if (client != NULL) {
+ freeme = gsm_client_get_app_name (client);
+ name = freeme;
+ }
+ }
+ }
+
+ if (name == NULL) {
+ if (! IS_STRING_EMPTY (app_id)) {
+ name = app_id;
+ } else {
+ name = _("Unknown");
+ }
+ }
+
+ if (pixbuf == NULL) {
+ pixbuf = _load_icon (gtk_icon_theme_get_default (),
+ "mate-windows",
+ DEFAULT_ICON_SIZE,
+ DEFAULT_ICON_SIZE,
+ DEFAULT_ICON_SIZE,
+ NULL);
+ }
+
+ gtk_list_store_insert_with_values (dialog->priv->list_store,
+ NULL, 0,
+ INHIBIT_IMAGE_COLUMN, pixbuf,
+ INHIBIT_NAME_COLUMN, name,
+ INHIBIT_REASON_COLUMN, gsm_inhibitor_peek_reason (inhibitor),
+ INHIBIT_ID_COLUMN, gsm_inhibitor_peek_id (inhibitor),
+ -1);
+
+ g_free (desktop_filename);
+ g_free (freeme);
+ if (pixbuf != NULL) {
+ g_object_unref (pixbuf);
+ }
+ if (desktop_file != NULL) {
+ egg_desktop_file_free (desktop_file);
+ }
+}
+
+static gboolean
+model_has_one_entry (GtkTreeModel *model)
+{
+ guint n_rows;
+
+ n_rows = gtk_tree_model_iter_n_children (model, NULL);
+ g_debug ("Model has %d rows", n_rows);
+
+ return (n_rows > 0 && n_rows < 2);
+}
+
+static void
+update_dialog_text (GsmInhibitDialog *dialog)
+{
+ const char *description_text;
+ const char *header_text;
+ GtkWidget *widget;
+
+ if (model_has_one_entry (GTK_TREE_MODEL (dialog->priv->list_store))) {
+ g_debug ("Found one entry in model");
+ header_text = _("A program is still running:");
+ description_text = _("Waiting for the program to finish. Interrupting the program may cause you to lose work.");
+ } else {
+ g_debug ("Found multiple entries (or none) in model");
+ header_text = _("Some programs are still running:");
+ description_text = _("Waiting for programs to finish. Interrupting these programs may cause you to lose work.");
+ }
+
+ widget = GTK_WIDGET (gtk_builder_get_object (dialog->priv->xml,
+ "header-label"));
+ if (widget != NULL) {
+ char *markup;
+ markup = g_strdup_printf ("<b>%s</b>", header_text);
+ gtk_label_set_markup (GTK_LABEL (widget), markup);
+ g_free (markup);
+ }
+
+ widget = GTK_WIDGET (gtk_builder_get_object (dialog->priv->xml,
+ "description-label"));
+ if (widget != NULL) {
+ gtk_label_set_text (GTK_LABEL (widget), description_text);
+ }
+}
+
+static void
+on_store_inhibitor_added (GsmStore *store,
+ const char *id,
+ GsmInhibitDialog *dialog)
+{
+ GsmInhibitor *inhibitor;
+ GtkTreeIter iter;
+
+ g_debug ("GsmInhibitDialog: inhibitor added: %s", id);
+
+ if (dialog->priv->is_done) {
+ return;
+ }
+
+ inhibitor = (GsmInhibitor *)gsm_store_lookup (store, id);
+
+ /* Add to model */
+ if (! find_inhibitor (dialog, id, &iter)) {
+ add_inhibitor (dialog, inhibitor);
+ update_dialog_text (dialog);
+ }
+
+}
+
+static void
+on_store_inhibitor_removed (GsmStore *store,
+ const char *id,
+ GsmInhibitDialog *dialog)
+{
+ GtkTreeIter iter;
+
+ g_debug ("GsmInhibitDialog: inhibitor removed: %s", id);
+
+ if (dialog->priv->is_done) {
+ return;
+ }
+
+ /* Remove from model */
+ if (find_inhibitor (dialog, id, &iter)) {
+ gtk_list_store_remove (dialog->priv->list_store, &iter);
+ update_dialog_text (dialog);
+ }
+
+ /* if there are no inhibitors left then trigger response */
+ if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->priv->list_store), &iter)) {
+ gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
+ }
+}
+
+static void
+gsm_inhibit_dialog_set_inhibitor_store (GsmInhibitDialog *dialog,
+ GsmStore *store)
+{
+ g_return_if_fail (GSM_IS_INHIBIT_DIALOG (dialog));
+
+ if (store != NULL) {
+ g_object_ref (store);
+ }
+
+ if (dialog->priv->inhibitors != NULL) {
+ g_signal_handlers_disconnect_by_func (dialog->priv->inhibitors,
+ on_store_inhibitor_added,
+ dialog);
+ g_signal_handlers_disconnect_by_func (dialog->priv->inhibitors,
+ on_store_inhibitor_removed,
+ dialog);
+
+ g_object_unref (dialog->priv->inhibitors);
+ }
+
+
+ g_debug ("GsmInhibitDialog: setting store %p", store);
+
+ dialog->priv->inhibitors = store;
+
+ if (dialog->priv->inhibitors != NULL) {
+ g_signal_connect (dialog->priv->inhibitors,
+ "added",
+ G_CALLBACK (on_store_inhibitor_added),
+ dialog);
+ g_signal_connect (dialog->priv->inhibitors,
+ "removed",
+ G_CALLBACK (on_store_inhibitor_removed),
+ dialog);
+ }
+}
+
+static void
+gsm_inhibit_dialog_set_client_store (GsmInhibitDialog *dialog,
+ GsmStore *store)
+{
+ g_return_if_fail (GSM_IS_INHIBIT_DIALOG (dialog));
+
+ if (store != NULL) {
+ g_object_ref (store);
+ }
+
+ if (dialog->priv->clients != NULL) {
+ g_object_unref (dialog->priv->clients);
+ }
+
+ dialog->priv->clients = store;
+}
+
+static void
+gsm_inhibit_dialog_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GsmInhibitDialog *dialog = GSM_INHIBIT_DIALOG (object);
+
+ switch (prop_id) {
+ case PROP_ACTION:
+ gsm_inhibit_dialog_set_action (dialog, g_value_get_int (value));
+ break;
+ case PROP_INHIBITOR_STORE:
+ gsm_inhibit_dialog_set_inhibitor_store (dialog, g_value_get_object (value));
+ break;
+ case PROP_CLIENT_STORE:
+ gsm_inhibit_dialog_set_client_store (dialog, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gsm_inhibit_dialog_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GsmInhibitDialog *dialog = GSM_INHIBIT_DIALOG (object);
+
+ switch (prop_id) {
+ case PROP_ACTION:
+ g_value_set_int (value, dialog->priv->action);
+ break;
+ case PROP_INHIBITOR_STORE:
+ g_value_set_object (value, dialog->priv->inhibitors);
+ break;
+ case PROP_CLIENT_STORE:
+ g_value_set_object (value, dialog->priv->clients);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+name_cell_data_func (GtkTreeViewColumn *tree_column,
+ GtkCellRenderer *cell,
+ GtkTreeModel *model,
+ GtkTreeIter *iter,
+ GsmInhibitDialog *dialog)
+{
+ char *name;
+ char *reason;
+ char *markup;
+
+ name = NULL;
+ reason = NULL;
+ gtk_tree_model_get (model,
+ iter,
+ INHIBIT_NAME_COLUMN, &name,
+ INHIBIT_REASON_COLUMN, &reason,
+ -1);
+
+ markup = g_strdup_printf ("<b>%s</b>\n"
+ "<span size=\"small\">%s</span>",
+ name ? name : "(null)",
+ reason ? reason : "(null)");
+
+ g_free (name);
+ g_free (reason);
+
+ g_object_set (cell, "markup", markup, NULL);
+ g_free (markup);
+}
+
+static gboolean
+add_to_model (const char *id,
+ GsmInhibitor *inhibitor,
+ GsmInhibitDialog *dialog)
+{
+ add_inhibitor (dialog, inhibitor);
+ return FALSE;
+}
+
+static void
+populate_model (GsmInhibitDialog *dialog)
+{
+ gsm_store_foreach_remove (dialog->priv->inhibitors,
+ (GsmStoreFunc)add_to_model,
+ dialog);
+ update_dialog_text (dialog);
+}
+
+static void
+setup_dialog (GsmInhibitDialog *dialog)
+{
+ const char *button_text;
+ GtkWidget *treeview;
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *renderer;
+
+ switch (dialog->priv->action) {
+ case GSM_LOGOUT_ACTION_SWITCH_USER:
+ button_text = _("Switch User Anyway");
+ break;
+ case GSM_LOGOUT_ACTION_LOGOUT:
+ button_text = _("Log Out Anyway");
+ break;
+ case GSM_LOGOUT_ACTION_SLEEP:
+ button_text = _("Suspend Anyway");
+ break;
+ case GSM_LOGOUT_ACTION_HIBERNATE:
+ button_text = _("Hibernate Anyway");
+ break;
+ case GSM_LOGOUT_ACTION_SHUTDOWN:
+ button_text = _("Shut Down Anyway");
+ break;
+ case GSM_LOGOUT_ACTION_REBOOT:
+ button_text = _("Reboot Anyway");
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ _("Lock Screen"),
+ DIALOG_RESPONSE_LOCK_SCREEN);
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ _("Cancel"),
+ GTK_RESPONSE_CANCEL);
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ button_text,
+ GTK_RESPONSE_ACCEPT);
+ g_signal_connect (dialog,
+ "response",
+ G_CALLBACK (on_response),
+ dialog);
+
+ dialog->priv->list_store = gtk_list_store_new (NUMBER_OF_COLUMNS,
+ GDK_TYPE_PIXBUF,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ G_TYPE_STRING);
+
+ treeview = GTK_WIDGET (gtk_builder_get_object (dialog->priv->xml,
+ "inhibitors-treeview"));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
+ gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
+ GTK_TREE_MODEL (dialog->priv->list_store));
+
+ /* IMAGE COLUMN */
+ renderer = gtk_cell_renderer_pixbuf_new ();
+ column = gtk_tree_view_column_new ();
+ gtk_tree_view_column_pack_start (column, renderer, FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+
+ gtk_tree_view_column_set_attributes (column,
+ renderer,
+ "pixbuf", INHIBIT_IMAGE_COLUMN,
+ NULL);
+
+ g_object_set (renderer, "xalign", 1.0, NULL);
+
+ /* NAME COLUMN */
+ renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new ();
+ gtk_tree_view_column_pack_start (column, renderer, FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+ gtk_tree_view_column_set_cell_data_func (column,
+ renderer,
+ (GtkTreeCellDataFunc) name_cell_data_func,
+ dialog,
+ NULL);
+
+ gtk_tree_view_set_tooltip_column (GTK_TREE_VIEW (treeview),
+ INHIBIT_REASON_COLUMN);
+
+ populate_model (dialog);
+}
+
+static GObject *
+gsm_inhibit_dialog_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_properties)
+{
+ GsmInhibitDialog *dialog;
+
+ dialog = GSM_INHIBIT_DIALOG (G_OBJECT_CLASS (gsm_inhibit_dialog_parent_class)->constructor (type,
+ n_construct_properties,
+ construct_properties));
+
+#ifdef HAVE_XRENDER
+ gdk_error_trap_push ();
+ if (XRenderQueryExtension (GDK_DISPLAY (), &dialog->priv->xrender_event_base, &dialog->priv->xrender_error_base)) {
+ g_debug ("GsmInhibitDialog: Initialized XRender extension");
+ dialog->priv->have_xrender = TRUE;
+ } else {
+ g_debug ("GsmInhibitDialog: Unable to initialize XRender extension");
+ dialog->priv->have_xrender = FALSE;
+ }
+ gdk_display_sync (gdk_display_get_default ());
+ gdk_error_trap_pop ();
+#endif /* HAVE_XRENDER */
+
+ /* FIXME: turn this on when it is ready */
+ dialog->priv->have_xrender = FALSE;
+
+ setup_dialog (dialog);
+
+ gtk_widget_show_all (GTK_WIDGET (dialog));
+
+ return G_OBJECT (dialog);
+}
+
+static void
+gsm_inhibit_dialog_dispose (GObject *object)
+{
+ GsmInhibitDialog *dialog;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GSM_IS_INHIBIT_DIALOG (object));
+
+ dialog = GSM_INHIBIT_DIALOG (object);
+
+ g_debug ("GsmInhibitDialog: dispose called");
+
+ if (dialog->priv->list_store != NULL) {
+ g_object_unref (dialog->priv->list_store);
+ dialog->priv->list_store = NULL;
+ }
+
+ if (dialog->priv->inhibitors != NULL) {
+ g_signal_handlers_disconnect_by_func (dialog->priv->inhibitors,
+ on_store_inhibitor_added,
+ dialog);
+ g_signal_handlers_disconnect_by_func (dialog->priv->inhibitors,
+ on_store_inhibitor_removed,
+ dialog);
+
+ g_object_unref (dialog->priv->inhibitors);
+ dialog->priv->inhibitors = NULL;
+ }
+
+ if (dialog->priv->xml != NULL) {
+ g_object_unref (dialog->priv->xml);
+ dialog->priv->xml = NULL;
+ }
+
+ G_OBJECT_CLASS (gsm_inhibit_dialog_parent_class)->dispose (object);
+}
+
+static void
+gsm_inhibit_dialog_class_init (GsmInhibitDialogClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = gsm_inhibit_dialog_get_property;
+ object_class->set_property = gsm_inhibit_dialog_set_property;
+ object_class->constructor = gsm_inhibit_dialog_constructor;
+ object_class->dispose = gsm_inhibit_dialog_dispose;
+ object_class->finalize = gsm_inhibit_dialog_finalize;
+
+ g_object_class_install_property (object_class,
+ PROP_ACTION,
+ g_param_spec_int ("action",
+ "action",
+ "action",
+ -1,
+ G_MAXINT,
+ -1,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ g_object_class_install_property (object_class,
+ PROP_INHIBITOR_STORE,
+ g_param_spec_object ("inhibitor-store",
+ NULL,
+ NULL,
+ GSM_TYPE_STORE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ g_object_class_install_property (object_class,
+ PROP_CLIENT_STORE,
+ g_param_spec_object ("client-store",
+ NULL,
+ NULL,
+ GSM_TYPE_STORE,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+
+ g_type_class_add_private (klass, sizeof (GsmInhibitDialogPrivate));
+}
+
+static void
+gsm_inhibit_dialog_init (GsmInhibitDialog *dialog)
+{
+ GtkWidget *content_area;
+ GtkWidget *widget;
+ GError *error;
+
+ dialog->priv = GSM_INHIBIT_DIALOG_GET_PRIVATE (dialog);
+
+ dialog->priv->xml = gtk_builder_new ();
+ gtk_builder_set_translation_domain (dialog->priv->xml, GETTEXT_PACKAGE);
+
+ error = NULL;
+ if (!gtk_builder_add_from_file (dialog->priv->xml,
+ GTKBUILDER_DIR "/" GTKBUILDER_FILE,
+ &error)) {
+ if (error) {
+ g_warning ("Could not load inhibitor UI file: %s",
+ error->message);
+ g_error_free (error);
+ } else {
+ g_warning ("Could not load inhibitor UI file.");
+ }
+ }
+
+ content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+ widget = GTK_WIDGET (gtk_builder_get_object (dialog->priv->xml,
+ "main-box"));
+ gtk_container_add (GTK_CONTAINER (content_area), widget);
+
+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
+ gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+ gtk_window_set_icon_name (GTK_WINDOW (dialog), "system-log-out");
+ gtk_window_set_title (GTK_WINDOW (dialog), "");
+ g_object_set (dialog,
+ "allow-shrink", FALSE,
+ "allow-grow", FALSE,
+ NULL);
+}
+
+static void
+gsm_inhibit_dialog_finalize (GObject *object)
+{
+ GsmInhibitDialog *dialog;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GSM_IS_INHIBIT_DIALOG (object));
+
+ dialog = GSM_INHIBIT_DIALOG (object);
+
+ g_return_if_fail (dialog->priv != NULL);
+
+ g_debug ("GsmInhibitDialog: finalizing");
+
+ G_OBJECT_CLASS (gsm_inhibit_dialog_parent_class)->finalize (object);
+}
+
+GtkWidget *
+gsm_inhibit_dialog_new (GsmStore *inhibitors,
+ GsmStore *clients,
+ int action)
+{
+ GObject *object;
+
+ object = g_object_new (GSM_TYPE_INHIBIT_DIALOG,
+ "action", action,
+ "inhibitor-store", inhibitors,
+ "client-store", clients,
+ NULL);
+
+ return GTK_WIDGET (object);
+}