1 files changed, 1192 insertions, 0 deletions
diff --git a/polkitgtkmate/polkitlockbutton.c b/polkitgtkmate/polkitlockbutton.c
new file mode 100644
index 0000000..2aa334a
--- /dev/null
+++ b/polkitgtkmate/polkitlockbutton.c
@@ -0,0 +1,1192 @@
+/*
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author: David Zeuthen <[email protected]>
+ */
+
+#include "config.h"
+
+#include <glib/gi18n-lib.h>
+#include <string.h>
+#include <polkit/polkit.h>
+
+#include "polkitlockbutton.h"
+
+/**
+ * SECTION:polkitlockbutton
+ * @title: PolkitLockButton
+ * @short_description: Widget for obtaining/revoking authorizations
+ * @stability: Stable
+ *
+ * #PolkitLockButton is a widget that can be used in control panels to
+ * allow users to obtain and revoke authorizations needed for the
+ * control panel UI to function.
+ *
+ * If the user lacks the authorization but authorization can be
+ * obtained through authentication, the widget looks like this
+ * <mediaobject id="lock-button-locked">
+ * <imageobject>
+ * <imagedata fileref="polkit-lock-button-locked.png" format="PNG"/>
+ * </imageobject>
+ * </mediaobject>
+ * and the user can click the button to obtain the authorization. This
+ * will pop up an authentication dialog.
+ * Once authorization is obtained, the widget changes to this
+ * <mediaobject id="lock-button-unlocked">
+ * <imageobject>
+ * <imagedata fileref="polkit-lock-button-unlocked.png" format="PNG"/>
+ * </imageobject>
+ * </mediaobject>
+ * and the authorization can be dropped by clicking the button.
+ * If the user is not able to obtain authorization at all, the widget
+ * looks like this
+ * <mediaobject id="lock-button-unlocked-not-authorized">
+ * <imageobject>
+ * <imagedata fileref="polkit-lock-button-not-authorized.png" format="PNG"/>
+ * </imageobject>
+ * </mediaobject>
+ * If the user is authorized (either implicitly via the .policy file
+ * defaults or through e.g. Local Authority configuration) and no
+ * authentication is necessary and the Authority Implementation
+ * supports lock-down, the widget looks like this
+ * <mediaobject id="lock-button-unlocked-lock-down">
+ * <imageobject>
+ * <imagedata fileref="polkit-lock-button-lock-down.png" format="PNG"/>
+ * </imageobject>
+ * </mediaobject>
+ * allowing the user to lock down the action. The lockdown can be
+ * removed by right clicking the button - the user can discover this
+ * through the tooltip. If the Authority implementation does not
+ * support lockdown, the widget will be hidden.
+ *
+ * Finally, if the user is not authorized but authorization can be
+ * obtained and the obtained authorization will be a one-shot
+ * authorization, the widget will be hidden. This means that any
+ * attempt to use the Mechanism that requires authorization for the
+ * specified action will always prompt for authentication. This
+ * condition happens exactly when
+ * (!polkit_lock_button_get_is_authorized() &&
+ * polkit_lock_button_get_can_obtain() &&
+ * !polkit_lock_button_get_is_visible()) is %TRUE.
+ *
+ * Typically #PolkitLockButton is only useful for actions where
+ * authorization is obtained through authentication (and retained) or
+ * where users are implictly authorized (cf. the defaults specified in
+ * the <literal>.policy</literal> file for the action) but note that
+ * this behavior can be overridden by the Authority implementation.
+ *
+ * The typical usage of this widget is like this:
+ * <programlisting>
+ * static void
+ * update_sensitivity_according_to_lock_button (FooBar *bar)
+ * {
+ * gboolean make_sensitive;
+ *
+ * make_sensitive = FALSE;
+ * if (polkit_lock_button_get_is_authorized (POLKIT_LOCK_BUTTON (bar->priv->lock_button)))
+ * {
+ * make_sensitive = TRUE;
+ * }
+ * else
+ * {
+ * /<!-- -->* Catch the case where authorization is one-shot - this means
+ * * an authentication dialog will be shown every time a widget the user
+ * * manipulates calls into the Mechanism.
+ * *<!-- -->/
+ * if (polkit_lock_button_get_can_obtain (POLKIT_LOCK_BUTTON (bar->priv->lock_button)) &&
+ * !polkit_lock_button_get_is_visible (POLKIT_LOCK_BUTTON (bar->priv->lock_button)))
+ * make_sensitive = TRUE;
+ * }
+ *
+ *
+ * /<!-- -->* Make all widgets relying on authorization sensitive according to
+ * * the value of make_sensitive.
+ * *<!-- -->/
+ * }
+ *
+ * static void
+ * on_lock_button_changed (PolkitLockButton *button,
+ * gpointer user_data)
+ * {
+ * FooBar *bar = FOO_BAR (user_data);
+ *
+ * update_sensitivity_according_to_lock_button (bar);
+ * }
+ *
+ * static void
+ * foo_bar_init (FooBar *bar)
+ * {
+ * /<!-- -->* Construct other widgets *<!-- -->/
+ *
+ * bar->priv->lock_button = polkit_lock_button_new ("org.project.mechanism.action-name");
+ * g_signal_connect (bar->priv->lock_button,
+ * "changed",
+ * G_CALLBACK (on_lock_button_changed),
+ * bar);
+ * update_sensitity_according_to_lock_button (bar);
+ *
+ * /<!-- -->* Pack bar->priv->lock_button into widget hierarchy *<!-- -->/
+ * }
+ * </programlisting>
+ */
+
+struct _PolkitLockButtonPrivate {
+ PolkitAuthority* authority;
+ PolkitSubject* subject;
+ gchar* action_id;
+
+ gchar* text_unlock;
+ gchar* text_lock;
+ gchar* text_lock_down;
+ gchar* text_not_authorized;
+
+ gchar* tooltip_unlock;
+ gchar* tooltip_lock;
+ gchar* tooltip_lock_down;
+ gchar* tooltip_not_authorized;
+
+ GtkWidget* button;
+ GtkWidget* label;
+
+ gboolean can_obtain;
+ gboolean retains_after_challenge;
+ gboolean authorized;
+ gboolean hidden;
+
+ /* is non-NULL exactly when we are authorized and have a temporary authorization */
+ gchar* tmp_authz_id;
+
+ /* This is non-NULL exactly when we have a non-interactive check outstanding */
+ GCancellable* check_cancellable;
+
+ /* This is non-NULL exactly when we have an interactive check outstanding */
+ GCancellable* interactive_check_cancellable;
+};
+
+enum{
+ PROP_0,
+ PROP_ACTION_ID,
+ PROP_IS_AUTHORIZED,
+ PROP_IS_VISIBLE,
+ PROP_CAN_OBTAIN,
+ PROP_TEXT_UNLOCK,
+ PROP_TEXT_LOCK,
+ PROP_TEXT_LOCK_DOWN,
+ PROP_TEXT_NOT_AUTHORIZED,
+ PROP_TOOLTIP_UNLOCK,
+ PROP_TOOLTIP_LOCK,
+ PROP_TOOLTIP_LOCK_DOWN,
+ PROP_TOOLTIP_NOT_AUTHORIZED,
+};
+
+enum {
+ CHANGED_SIGNAL,
+ LAST_SIGNAL,
+};
+
+static guint signals[LAST_SIGNAL] = {0, };
+
+static void initiate_check(PolkitLockButton* button);
+static void do_sync_check(PolkitLockButton* button);
+static void update_state(PolkitLockButton* button);
+
+static void on_authority_changed(PolkitAuthority* authority, gpointer user_data);
+
+static void on_clicked(GtkButton* button, gpointer user_data);
+
+G_DEFINE_TYPE(PolkitLockButton, polkit_lock_button, GTK_TYPE_HBOX);
+
+static void polkit_lock_button_finalize(GObject* object)
+{
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON(object);
+
+ g_free(button->priv->action_id);
+ g_free(button->priv->tmp_authz_id);
+ g_object_unref(button->priv->subject);
+
+ if (button->priv->check_cancellable != NULL)
+ {
+ g_cancellable_cancel(button->priv->check_cancellable);
+ g_object_unref(button->priv->check_cancellable);
+ }
+
+ if (button->priv->interactive_check_cancellable != NULL)
+ {
+ g_cancellable_cancel(button->priv->interactive_check_cancellable);
+ g_object_unref(button->priv->interactive_check_cancellable);
+ }
+
+ g_signal_handlers_disconnect_by_func(button->priv->authority, on_authority_changed, button);
+ g_object_unref(button->priv->authority);
+
+ if (G_OBJECT_CLASS(polkit_lock_button_parent_class)->finalize != NULL)
+ {
+ G_OBJECT_CLASS(polkit_lock_button_parent_class)->finalize(object);
+ }
+}
+
+static void
+polkit_lock_button_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (object);
+
+ switch (property_id)
+ {
+ case PROP_ACTION_ID:
+ g_value_set_string (value, button->priv->action_id);
+ break;
+
+ case PROP_IS_AUTHORIZED:
+ g_value_set_boolean (value, button->priv->authorized);
+ break;
+
+ case PROP_IS_VISIBLE:
+ g_value_set_boolean (value, !button->priv->hidden);
+ break;
+
+ case PROP_CAN_OBTAIN:
+ g_value_set_boolean (value, button->priv->can_obtain);
+ break;
+
+ case PROP_TEXT_UNLOCK:
+ g_value_set_string (value, button->priv->text_unlock);
+ break;
+
+ case PROP_TEXT_LOCK:
+ g_value_set_string (value, button->priv->text_lock);
+ break;
+
+ case PROP_TEXT_LOCK_DOWN:
+ g_value_set_string (value, button->priv->text_lock_down);
+ break;
+
+ case PROP_TEXT_NOT_AUTHORIZED:
+ g_value_set_string (value, button->priv->text_not_authorized);
+ break;
+
+ case PROP_TOOLTIP_UNLOCK:
+ g_value_set_string (value, button->priv->tooltip_unlock);
+ break;
+
+ case PROP_TOOLTIP_LOCK:
+ g_value_set_string (value, button->priv->tooltip_lock);
+ break;
+
+ case PROP_TOOLTIP_LOCK_DOWN:
+ g_value_set_string (value, button->priv->tooltip_lock_down);
+ break;
+
+ case PROP_TOOLTIP_NOT_AUTHORIZED:
+ g_value_set_string (value, button->priv->tooltip_not_authorized);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+static void
+polkit_lock_button_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (object);
+
+ switch (property_id)
+ {
+ case PROP_ACTION_ID:
+ button->priv->action_id = g_value_dup_string (value);
+ break;
+
+ case PROP_TEXT_UNLOCK:
+ polkit_lock_button_set_unlock_text (button, g_value_get_string (value));
+ break;
+
+ case PROP_TEXT_LOCK:
+ polkit_lock_button_set_lock_text (button, g_value_get_string (value));
+ break;
+
+ case PROP_TEXT_LOCK_DOWN:
+ polkit_lock_button_set_lock_down_text (button, g_value_get_string (value));
+ break;
+
+ case PROP_TEXT_NOT_AUTHORIZED:
+ polkit_lock_button_set_not_authorized_text (button, g_value_get_string (value));
+ break;
+
+ case PROP_TOOLTIP_UNLOCK:
+ polkit_lock_button_set_unlock_tooltip (button, g_value_get_string (value));
+ break;
+
+ case PROP_TOOLTIP_LOCK:
+ polkit_lock_button_set_lock_tooltip (button, g_value_get_string (value));
+ break;
+
+ case PROP_TOOLTIP_LOCK_DOWN:
+ polkit_lock_button_set_lock_down_tooltip (button, g_value_get_string (value));
+ break;
+
+ case PROP_TOOLTIP_NOT_AUTHORIZED:
+ polkit_lock_button_set_not_authorized_tooltip (button, g_value_get_string (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ break;
+ }
+}
+
+
+static void
+polkit_lock_button_init (PolkitLockButton *button)
+{
+ button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
+ POLKIT_TYPE_LOCK_BUTTON,
+ PolkitLockButtonPrivate);
+
+}
+
+static void
+polkit_lock_button_constructed (GObject *object)
+{
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (object);
+ GError *error;
+
+ gtk_box_set_spacing (GTK_BOX (button), 2);
+
+ /* TODO: should be async+failable (e.g. GAsyncInitable) instead of this */
+ error = NULL;
+ button->priv->authority = polkit_authority_get_sync (NULL /* GCancellable* */, &error);
+ if (button->priv->authority == NULL)
+ {
+ g_critical ("Error getting authority: %s", error->message);
+ g_error_free (error);
+ }
+ g_signal_connect (button->priv->authority,
+ "changed",
+ G_CALLBACK (on_authority_changed),
+ button);
+
+ button->priv->button = gtk_button_new ();
+ gtk_button_set_relief (GTK_BUTTON (button->priv->button), GTK_RELIEF_NONE);
+ /* image is set in update_state() */
+ g_signal_connect (button->priv->button,
+ "clicked",
+ G_CALLBACK (on_clicked),
+ button);
+
+ gtk_box_pack_start (GTK_BOX (button),
+ button->priv->button,
+ FALSE,
+ FALSE,
+ 0);
+
+ button->priv->label = gtk_label_new ("");
+ gtk_box_pack_start (GTK_BOX (button),
+ button->priv->label,
+ FALSE,
+ FALSE,
+ 0);
+
+ /* take control of visibility of child widgets */
+ gtk_widget_set_no_show_all (button->priv->button, TRUE);
+ gtk_widget_set_no_show_all (button->priv->label, TRUE);
+
+ if (button->priv->subject == NULL)
+ {
+ button->priv->subject = polkit_unix_process_new (getpid ());
+ }
+
+ /* synchronously check on construction - TODO: we could implement GAsyncInitable
+ * in the future to avoid this sync check
+ */
+ do_sync_check (button);
+
+ update_state (button);
+
+ if (G_OBJECT_CLASS (polkit_lock_button_parent_class)->constructed != NULL)
+ G_OBJECT_CLASS (polkit_lock_button_parent_class)->constructed (object);
+}
+
+static void
+polkit_lock_button_class_init (PolkitLockButtonClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->finalize = polkit_lock_button_finalize;
+ gobject_class->get_property = polkit_lock_button_get_property;
+ gobject_class->set_property = polkit_lock_button_set_property;
+ gobject_class->constructed = polkit_lock_button_constructed;
+
+ g_type_class_add_private (klass, sizeof (PolkitLockButtonPrivate));
+
+ /**
+ * PolkitLockButton:action-id:
+ *
+ * The action identifier to use for the button.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_ACTION_ID,
+ g_param_spec_string ("action-id",
+ _("Action Identifier"),
+ _("The action identifier to use for the button"),
+ NULL,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:is-authorized:
+ *
+ * Whether the process is authorized.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IS_AUTHORIZED,
+ g_param_spec_boolean ("is-authorized",
+ _("Is Authorized"),
+ _("Whether the process is authorized"),
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:is-visible:
+ *
+ * Whether the widget is visible.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IS_VISIBLE,
+ g_param_spec_boolean ("is-visible",
+ _("Is Visible"),
+ _("Whether the widget is visible"),
+ TRUE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:can-obtain:
+ *
+ * Whether authorization can be obtained.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CAN_OBTAIN,
+ g_param_spec_boolean ("can-obtain",
+ _("Can Obtain"),
+ _("Whether authorization can be obtained"),
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:text-unlock:
+ *
+ * The text to display when prompting the user to unlock.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TEXT_UNLOCK,
+ g_param_spec_string ("text-unlock",
+ _("Unlock Text"),
+ _("The text to display when prompting the user to unlock."),
+ _("Click to make changes"),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:tooltip-unlock:
+ *
+ * The tooltip to display when prompting the user to unlock.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TOOLTIP_UNLOCK,
+ g_param_spec_string ("tooltip-unlock",
+ _("Unlock Tooltip"),
+ _("The tooltip to display when prompting the user to unlock."),
+ _("Authentication is needed to make changes."),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:text-lock:
+ *
+ * The text to display when prompting the user to lock.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TEXT_LOCK,
+ g_param_spec_string ("text-lock",
+ _("Lock Text"),
+ _("The text to display when prompting the user to lock."),
+ _("Click to prevent changes"),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:tooltip-lock:
+ *
+ * The tooltip to display when prompting the user to lock.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TOOLTIP_LOCK,
+ g_param_spec_string ("tooltip-lock",
+ _("Lock Tooltip"),
+ _("The tooltip to display when prompting the user to lock."),
+ _("To prevent further changes, click the lock."),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:text-lock-down:
+ *
+ * The text to display when prompting the user to lock down the action for all users.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TEXT_LOCK_DOWN,
+ g_param_spec_string ("text-lock-down",
+ _("Lock Down Text"),
+ _("The text to display when prompting the user to lock down the action for all users."),
+ _("Click to lock down"),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:tooltip-lock-down:
+ *
+ * The tooltip to display when prompting the user to lock down the action for all users.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TOOLTIP_LOCK_DOWN,
+ g_param_spec_string ("tooltip-lock-down",
+ _("Lock Down Tooltip"),
+ _("The tooltip to display when prompting the user to lock down the action for all users."),
+ _("To prevent users without administrative privileges from making changes, click the lock."),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:text-not-authorized:
+ *
+ * The text to display when the user cannot obtain authorization through authentication.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TEXT_NOT_AUTHORIZED,
+ g_param_spec_string ("text-not-authorized",
+ _("Unlock Text"),
+ _("The text to display when the user cannot obtain authorization through authentication."),
+ _("Not authorized to make changes"),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton:tooltip-not-authorized:
+ *
+ * The tooltip to display when the user cannot obtain authorization through authentication.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TOOLTIP_NOT_AUTHORIZED,
+ g_param_spec_string ("tooltip-not-authorized",
+ _("Unlock Tooltip"),
+ _("The tooltip to display when the user cannot obtain authorization through authentication."),
+ _("System policy prevents changes. Contact your system administator."),
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_NAME |
+ G_PARAM_STATIC_NICK |
+ G_PARAM_STATIC_BLURB));
+
+ /**
+ * PolkitLockButton::changed:
+ * @button: A #PolkitLockButton.
+ *
+ * Emitted when something on @button changes.
+ */
+ signals[CHANGED_SIGNAL] = g_signal_new ("changed",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PolkitLockButtonClass, changed),
+ NULL,
+ NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0);
+
+}
+
+/**
+ * polkit_lock_button_new:
+ * @action_id: An action identifer.
+ *
+ * Constructs a #PolkitLockButton for @action_id.
+ *
+ * Returns: A #PolkitLockButton.
+ */
+GtkWidget *
+polkit_lock_button_new (const gchar *action_id)
+{
+ g_return_val_if_fail (action_id != NULL, NULL);
+
+ return GTK_WIDGET (g_object_new (POLKIT_TYPE_LOCK_BUTTON,
+ "action-id", action_id,
+ NULL));
+}
+
+static void
+update_state (PolkitLockButton *button)
+{
+ const gchar *text;
+ const gchar *tooltip;
+ gboolean sensitive;
+ gboolean old_hidden;
+ GtkWidget *image;
+
+ old_hidden = button->priv->hidden;
+ button->priv->hidden = FALSE;
+
+ if (button->priv->authorized)
+ {
+ text = button->priv->text_lock;
+ tooltip = button->priv->tooltip_lock;
+ sensitive = TRUE;
+ /* if the authorization isn't temporary => ask if user wants to lock the authorization down the
+ * authority we're using has that capability
+ */
+ if (button->priv->tmp_authz_id == NULL)
+ {
+ //button->priv->hidden = TRUE;
+ }
+ }
+ else
+ {
+ if (button->priv->can_obtain && button->priv->retains_after_challenge)
+ {
+ /* can retain and obtain authorization => show the unlock button */
+ text = button->priv->text_unlock;
+ tooltip = button->priv->tooltip_unlock;
+ g_free (button->priv->tmp_authz_id);
+ button->priv->tmp_authz_id = NULL;
+ sensitive = TRUE;
+ }
+ else
+ {
+ if (button->priv->can_obtain)
+ {
+ /* we can obtain authorization, we just can't retain it => hidden */
+ button->priv->hidden = TRUE;
+ }
+ else
+ {
+ /* cannot even obtain authorization => tell user he can't have a pony */
+ text = button->priv->text_not_authorized;
+ tooltip = button->priv->tooltip_not_authorized;
+ g_free (button->priv->tmp_authz_id);
+ button->priv->tmp_authz_id = NULL;
+ sensitive = FALSE;
+ }
+ }
+ }
+
+ image = gtk_image_new_from_icon_name (button->priv->authorized ? "changes-allow" : "changes-prevent",
+ GTK_ICON_SIZE_SMALL_TOOLBAR);
+ gtk_button_set_image (GTK_BUTTON (button->priv->button), image);
+ gtk_label_set_text (GTK_LABEL (button->priv->label), text);
+ gtk_widget_set_sensitive (button->priv->button, sensitive);
+
+ gtk_widget_set_tooltip_markup (GTK_WIDGET (button->priv->label), tooltip);
+ gtk_widget_set_tooltip_markup (GTK_WIDGET (button->priv->button), tooltip);
+
+ if (button->priv->hidden)
+ {
+ gtk_widget_hide (button->priv->button);
+ gtk_widget_hide (button->priv->label);
+ }
+ else
+ {
+ gtk_widget_show (button->priv->button);
+ gtk_widget_show (button->priv->label);
+ }
+
+ if (old_hidden != button->priv->hidden)
+ g_object_notify (G_OBJECT (button), "is-visible");
+}
+
+static void
+on_authority_changed (PolkitAuthority *authority,
+ gpointer user_data)
+{
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (user_data);
+ initiate_check (button);
+}
+
+static void
+process_result (PolkitLockButton *button,
+ PolkitAuthorizationResult *result)
+{
+ gboolean old_can_obtain;
+ gboolean old_authorized;
+
+ old_can_obtain = button->priv->can_obtain;
+ old_authorized = button->priv->authorized;
+ button->priv->can_obtain = polkit_authorization_result_get_is_challenge (result);
+ button->priv->authorized = polkit_authorization_result_get_is_authorized (result);
+
+ /* save the temporary authorization id */
+ g_free (button->priv->tmp_authz_id);
+ button->priv->tmp_authz_id = g_strdup (polkit_authorization_result_get_temporary_authorization_id (result));
+ button->priv->retains_after_challenge = polkit_authorization_result_get_retains_authorization (result);
+
+ update_state (button);
+
+ if (old_can_obtain != button->priv->can_obtain ||
+ old_authorized != button->priv->authorized)
+ {
+ g_signal_emit (button,
+ signals[CHANGED_SIGNAL],
+ 0);
+ }
+
+ if (old_can_obtain != button->priv->can_obtain)
+ g_object_notify (G_OBJECT (button), "can-obtain");
+
+ if (old_authorized != button->priv->authorized)
+ g_object_notify (G_OBJECT (button), "is-authorized");
+}
+
+static void
+check_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ PolkitAuthority *authority = POLKIT_AUTHORITY (source_object);
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (user_data);
+ PolkitAuthorizationResult *result;
+ GError *error;
+
+ error = NULL;
+ result = polkit_authority_check_authorization_finish (authority,
+ res,
+ &error);
+ if (error != NULL)
+ {
+ g_warning ("Error checking authorization for action id `%s': %s",
+ button->priv->action_id,
+ error->message);
+ g_error_free (error);
+ }
+ else
+ {
+ process_result (button, result);
+ }
+
+ if (result != NULL)
+ g_object_unref (result);
+
+ if (button->priv->check_cancellable != NULL)
+ {
+ g_object_unref (button->priv->check_cancellable);
+ button->priv->check_cancellable = NULL;
+ }
+}
+
+static void
+initiate_check (PolkitLockButton *button)
+{
+
+ /* if we have a check pending already, then do nothing */
+ if (button->priv->check_cancellable != NULL)
+ goto out;
+
+ button->priv->check_cancellable = g_cancellable_new ();
+
+ polkit_authority_check_authorization (button->priv->authority,
+ button->priv->subject,
+ button->priv->action_id,
+ NULL, /* PolkitDetails */
+ POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE,
+ button->priv->check_cancellable,
+ check_cb,
+ button);
+
+ out:
+ ;
+}
+
+static void
+do_sync_check (PolkitLockButton *button)
+{
+
+ GError *error;
+ PolkitAuthorizationResult *result;
+
+ error = NULL;
+ result = polkit_authority_check_authorization_sync (button->priv->authority,
+ button->priv->subject,
+ button->priv->action_id,
+ NULL, /* PolkitDetails */
+ POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE,
+ NULL, /* cancellable */
+ &error);
+ if (error != NULL)
+ {
+ g_warning ("Error sync-checking authorization for action id `%s': %s",
+ button->priv->action_id,
+ error->message);
+ g_error_free (error);
+ }
+ else
+ {
+ process_result (button, result);
+ }
+
+ if (result != NULL)
+ g_object_unref (result);
+}
+
+static void
+interactive_check_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+
+ PolkitAuthority *authority = POLKIT_AUTHORITY (source_object);
+ PolkitLockButton *button = POLKIT_LOCK_BUTTON (user_data);
+ PolkitAuthorizationResult *result;
+ PolkitDetails *details;
+ GError *error;
+
+ error = NULL;
+ result = polkit_authority_check_authorization_finish (authority,
+ res,
+ &error);
+ if (error != NULL)
+ {
+ g_warning ("Error obtaining authorization for action id `%s': %s",
+ button->priv->action_id,
+ error->message);
+ g_error_free (error);
+ goto out;
+ }
+
+ /* state is updated in the ::changed signal handler */
+
+ /* save the temporary authorization id */
+ details = polkit_authorization_result_get_details (result);
+ if (details != NULL)
+ {
+ button->priv->tmp_authz_id = g_strdup (polkit_details_lookup (details,
+ "polkit.temporary_authorization_id"));
+ }
+
+ out:
+ if (result != NULL)
+ g_object_unref (result);
+
+ if (button->priv->interactive_check_cancellable != NULL)
+ {
+ g_object_unref (button->priv->interactive_check_cancellable);
+ button->priv->interactive_check_cancellable = NULL;
+ }
+}
+
+
+static void on_clicked(GtkButton* _button, gpointer user_data)
+{
+
+ PolkitLockButton* button = POLKIT_LOCK_BUTTON(user_data);
+
+ if (!button->priv->authorized && button->priv->can_obtain)
+ {
+
+ /* if we already have a pending interactive check, then do nothing */
+ if (button->priv->interactive_check_cancellable != NULL)
+ {
+ goto out;
+ }
+
+ button->priv->interactive_check_cancellable = g_cancellable_new();
+
+ polkit_authority_check_authorization(button->priv->authority, button->priv->subject, button->priv->action_id, NULL, /* PolkitDetails */ POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION, button->priv->interactive_check_cancellable, interactive_check_cb, button);
+ }
+ else if (button->priv->authorized && button->priv->tmp_authz_id != NULL)
+ {
+ polkit_authority_revoke_temporary_authorization_by_id (button->priv->authority, button->priv->tmp_authz_id, /* cancellable */ NULL, /* callback */ NULL, /* user_data */ NULL);
+ }
+
+ out:
+
+ update_state(button);
+}
+
+/**
+ * polkit_lock_button_get_is_authorized:
+ * @button: A #PolkitLockButton.
+ *
+ * Gets whether the process is authorized.
+ *
+ * Returns: %TRUE if authorized.
+ */
+gboolean polkit_lock_button_get_is_authorized(PolkitLockButton* button)
+{
+ g_return_val_if_fail(POLKIT_IS_LOCK_BUTTON(button), FALSE);
+ return button->priv->authorized;
+}
+
+/**
+ * polkit_lock_button_get_can_obtain:
+ * @button: A #PolkitLockButton.
+ *
+ * Gets whether the user can obtain an authorization through
+ * authentication.
+ *
+ * Returns: Whether the authorization is obtainable.
+ */
+gboolean polkit_lock_button_get_can_obtain(PolkitLockButton* button)
+{
+ g_return_val_if_fail(POLKIT_IS_LOCK_BUTTON(button), FALSE);
+ return button->priv->can_obtain;
+}
+
+/**
+ * polkit_lock_button_get_is_visible:
+ * @button: A #PolkitLockButton.
+ *
+ * Gets whether @button is currently being shown.
+ *
+ * Returns: %TRUE if @button has any visible UI elements.
+ */
+gboolean polkit_lock_button_get_is_visible(PolkitLockButton* button)
+{
+ g_return_val_if_fail(POLKIT_IS_LOCK_BUTTON(button), FALSE);
+ return !button->priv->hidden;
+}
+
+/**
+ * polkit_lock_button_set_unlock_text:
+ * @button: A #PolkitLockButton.
+ * @text: The text to set.
+ *
+ * Makes @button display @text when not authorized and clicking the button will obtain the authorization.
+ */
+void polkit_lock_button_set_unlock_text(PolkitLockButton* button, const gchar* text)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(text != NULL);
+
+ if (button->priv->text_unlock != NULL)
+ {
+ button->priv->text_unlock = g_strdup(text);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->text_unlock = g_strdup(text);
+ }
+}
+
+/**
+ * polkit_lock_button_set_lock_text:
+ * @button: A #PolkitLockButton.
+ * @text: The text to set.
+ *
+ * Makes @button display @text when authorized and clicking the button will revoke the authorization.
+ */
+void polkit_lock_button_set_lock_text(PolkitLockButton* button, const gchar* text)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(text != NULL);
+
+ if (button->priv->text_lock != NULL)
+ {
+ button->priv->text_lock = g_strdup(text);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->text_lock = g_strdup(text);
+ }
+}
+
+/**
+ * polkit_lock_button_set_lock_down_text:
+ * @button: A #PolkitLockButton.
+ * @text: The text to set.
+ *
+ * Makes @button display @text when authorized and it is possible to lock down the action.
+ */
+void polkit_lock_button_set_lock_down_text(PolkitLockButton* button, const gchar* text)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(text != NULL);
+
+ if (button->priv->text_lock_down != NULL)
+ {
+ button->priv->text_lock_down = g_strdup(text);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->text_lock_down = g_strdup(text);
+ }
+}
+
+/**
+ * polkit_lock_button_set_not_authorized_text:
+ * @button: A #PolkitLockButton.
+ * @text: The text to set.
+ *
+ * Makes @button display @text when an authorization cannot be obtained.
+ */
+void polkit_lock_button_set_not_authorized_text(PolkitLockButton* button, const gchar* text)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(text != NULL);
+
+ if (button->priv->text_not_authorized != NULL)
+ {
+ button->priv->text_not_authorized = g_strdup(text);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->text_not_authorized = g_strdup(text);
+ }
+}
+
+
+/**
+ * polkit_lock_button_set_unlock_tooltip:
+ * @button: A #PolkitLockButton.
+ * @tooltip: The text of the tooltip.
+ *
+ * Makes @button display @tooltip when not authorized and clicking the button will obtain the authorization.
+ */
+void polkit_lock_button_set_unlock_tooltip(PolkitLockButton* button, const gchar* tooltip)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(tooltip != NULL);
+
+ if (button->priv->tooltip_unlock != NULL)
+ {
+ button->priv->tooltip_unlock = g_strdup(tooltip);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->tooltip_unlock = g_strdup(tooltip);
+ }
+}
+
+/**
+ * polkit_lock_button_set_lock_tooltip:
+ * @button: A #PolkitLockButton.
+ * @tooltip: The text of the tooltip.
+ *
+ * Makes @button display @tooltip when authorized and clicking the button will revoke the authorization.
+ */
+void polkit_lock_button_set_lock_tooltip(PolkitLockButton* button, const gchar* tooltip)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(tooltip != NULL);
+
+ if (button->priv->tooltip_lock != NULL)
+ {
+ button->priv->tooltip_lock = g_strdup(tooltip);
+ update_state (button);
+ }
+ else
+ {
+ button->priv->tooltip_lock = g_strdup(tooltip);
+ }
+}
+
+/**
+ * polkit_lock_button_set_lock_down_tooltip:
+ * @button: A #PolkitLockButton.
+ * @tooltip: The text of the tooltip.
+ *
+ * Makes @button display @tooltip when authorized and it is possible to lock down the action.
+ */
+void polkit_lock_button_set_lock_down_tooltip(PolkitLockButton* button, const gchar* tooltip)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(tooltip != NULL);
+
+ if (button->priv->tooltip_lock_down != NULL)
+ {
+ button->priv->tooltip_lock_down = g_strdup(tooltip);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->tooltip_lock_down = g_strdup(tooltip);
+ }
+}
+
+/**
+ * polkit_lock_button_set_not_authorized_tooltip:
+ * @button: A #PolkitLockButton.
+ * @tooltip: The text of the tooltip.
+ *
+ * Makes @button display @tooltip when an authorization cannot be obtained.
+ */
+void polkit_lock_button_set_not_authorized_tooltip(PolkitLockButton* button, const gchar* tooltip)
+{
+ g_return_if_fail(POLKIT_IS_LOCK_BUTTON(button));
+ g_return_if_fail(tooltip != NULL);
+
+ if (button->priv->tooltip_not_authorized != NULL)
+ {
+ button->priv->tooltip_not_authorized = g_strdup(tooltip);
+ update_state(button);
+ }
+ else
+ {
+ button->priv->tooltip_not_authorized = g_strdup(tooltip);
+ }
+}