moving from https://github.com/perberos/mate-desktop-environment

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);
+}