Pileus Git - ~andy/gtk/blob - gtk/gtklockbutton.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Red Hat, Inc.
   3  * Author: Matthias Clasen
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include "gtklockbuttonprivate.h"
  22 #include "gtkbox.h"
  23 #include "gtkimage.h"
  24 #include "gtklabel.h"
  25 #include "gtksizegroup.h"
  26 #include "gtkintl.h"
  27 #include "a11y/gtklockbuttonaccessible.h"
  28
  29 /**
  30  * SECTION:gtklockbutton
  31  * @title: GtkLockButton
  32  * @short_description: A widget to unlock or lock privileged operations
  33  *
  34  * GtkLockButton is a widget that can be used in control panels or
  35  * preference dialogs to allow users to obtain and revoke authorizations
  36  * needed to operate the controls. The required authorization is represented
  37  * by a #GPermission object. Concrete implementations of #GPermission may use
  38  * PolicyKit or some other authorization framework. To obtain a PolicyKit-based
  39  * #GPermission, use polkit_permission_new().
  40  *
  41  * If the user is not currently allowed to perform the action, but can obtain
  42  * the permission, the widget looks like this
  43  * <informalexample><inlinegraphic fileref="lockbutton-locked.png"></inlinegraphic></informalexample>
  44  * and the user can click the button to request the permission. Depending
  45  * on the platform, this may pop up an authentication dialog or ask the user
  46  * to authenticate in some other way. Once the user has obtained the permission,
  47  * the widget changes to this
  48  * <informalexample><inlinegraphic fileref="lockbutton-unlocked.png"></inlinegraphic></informalexample>
  49  * and the permission can be dropped again by clicking the button. If the user
  50  * is not able to obtain the permission at all, the widget looks like this
  51  * <informalexample><inlinegraphic fileref="lockbutton-sorry.png"></inlinegraphic></informalexample>
  52  * If the user has the permission and cannot drop it, the button is hidden.
  53  *
  54  * The text (and tooltips) that are shown in the various cases can be adjusted
  55  * with the #GtkLockButton:text-lock, #GtkLockButton:text-unlock,
  56  * #GtkLockButton:tooltip-lock, #GtkLockButton:tooltip-unlock and
  57  * #GtkLockButton:tooltip-not-authorized properties.
  58  */
  59
  60 struct _GtkLockButtonPrivate
  61 {
  62   GPermission *permission;
  63   GCancellable *cancellable;
  64
  65   gchar *tooltip_lock;
  66   gchar *tooltip_unlock;
  67   gchar *tooltip_not_authorized;
  68   GIcon *icon_lock;
  69   GIcon *icon_unlock;
  70
  71   GtkWidget *box;
  72   GtkWidget *image;
  73   GtkWidget *label_lock;
  74   GtkWidget *label_unlock;
  75
  76   GtkSizeGroup *label_group;
  77 };
  78
  79 enum
  80 {
  81   PROP_0,
  82   PROP_PERMISSION,
  83   PROP_TEXT_LOCK,
  84   PROP_TEXT_UNLOCK,
  85   PROP_TOOLTIP_LOCK,
  86   PROP_TOOLTIP_UNLOCK,
  87   PROP_TOOLTIP_NOT_AUTHORIZED
  88 };
  89
  90 static void update_state (GtkLockButton *button);
  91 static void gtk_lock_button_clicked (GtkButton *button);
  92
  93 static void on_permission_changed (GPermission *permission,
  94                                    GParamSpec  *pspec,
  95                                    gpointer     user_data);
  96
  97 G_DEFINE_TYPE (GtkLockButton, gtk_lock_button, GTK_TYPE_BUTTON);
  98
  99 static void
 100 gtk_lock_button_finalize (GObject *object)
 101 {
 102   GtkLockButton *button = GTK_LOCK_BUTTON (object);
 103   GtkLockButtonPrivate *priv = button->priv;
 104
 105   g_free (priv->tooltip_lock);
 106   g_free (priv->tooltip_unlock);
 107   g_free (priv->tooltip_not_authorized);
 108
 109   g_object_unref (priv->icon_lock);
 110   g_object_unref (priv->icon_unlock);
 111   g_object_unref (priv->label_group);
 112
 113   if (priv->cancellable != NULL)
 114     {
 115       g_cancellable_cancel (priv->cancellable);
 116       g_object_unref (priv->cancellable);
 117     }
 118
 119   if (priv->permission)
 120     {
 121       g_signal_handlers_disconnect_by_func (priv->permission,
 122                                             on_permission_changed,
 123                                             button);
 124       g_object_unref (priv->permission);
 125     }
 126
 127   G_OBJECT_CLASS (gtk_lock_button_parent_class)->finalize (object);
 128 }
 129
 130 static void
 131 gtk_lock_button_get_property (GObject    *object,
 132                               guint       property_id,
 133                               GValue     *value,
 134                               GParamSpec *pspec)
 135 {
 136   GtkLockButton *button = GTK_LOCK_BUTTON (object);
 137   GtkLockButtonPrivate *priv = button->priv;
 138
 139   switch (property_id)
 140     {
 141     case PROP_PERMISSION:
 142       g_value_set_object (value, priv->permission);
 143       break;
 144
 145     case PROP_TEXT_LOCK:
 146       g_value_set_string (value, gtk_label_get_text (GTK_LABEL (priv->label_lock)));
 147       break;
 148
 149     case PROP_TEXT_UNLOCK:
 150       g_value_set_string (value, gtk_label_get_text (GTK_LABEL (priv->label_unlock)));
 151       break;
 152
 153     case PROP_TOOLTIP_LOCK:
 154       g_value_set_string (value, priv->tooltip_lock);
 155       break;
 156
 157     case PROP_TOOLTIP_UNLOCK:
 158       g_value_set_string (value, priv->tooltip_unlock);
 159       break;
 160
 161     case PROP_TOOLTIP_NOT_AUTHORIZED:
 162       g_value_set_string (value, priv->tooltip_not_authorized);
 163       break;
 164
 165     default:
 166       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 167       break;
 168     }
 169 }
 170
 171 static void
 172 gtk_lock_button_set_property (GObject      *object,
 173                               guint         property_id,
 174                               const GValue *value,
 175                               GParamSpec   *pspec)
 176 {
 177   GtkLockButton *button = GTK_LOCK_BUTTON (object);
 178   GtkLockButtonPrivate *priv = button->priv;
 179
 180   switch (property_id)
 181     {
 182     case PROP_PERMISSION:
 183       gtk_lock_button_set_permission (button, g_value_get_object (value));
 184       break;
 185
 186     case PROP_TEXT_LOCK:
 187       gtk_label_set_text (GTK_LABEL (priv->label_lock), g_value_get_string (value));
 188       break;
 189
 190     case PROP_TEXT_UNLOCK:
 191       gtk_label_set_text (GTK_LABEL (priv->label_unlock), g_value_get_string (value));
 192       break;
 193
 194     case PROP_TOOLTIP_LOCK:
 195       g_free (priv->tooltip_lock);
 196       priv->tooltip_lock = g_value_dup_string (value);
 197       break;
 198
 199     case PROP_TOOLTIP_UNLOCK:
 200       g_free (priv->tooltip_unlock);
 201       priv->tooltip_unlock = g_value_dup_string (value);
 202       break;
 203
 204     case PROP_TOOLTIP_NOT_AUTHORIZED:
 205       g_free (priv->tooltip_not_authorized);
 206       priv->tooltip_not_authorized = g_value_dup_string (value);
 207       break;
 208
 209     default:
 210       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 211       break;
 212     }
 213
 214   update_state (button);
 215 }
 216
 217 static void
 218 gtk_lock_button_init (GtkLockButton *button)
 219 {
 220   GtkLockButtonPrivate *priv;
 221   gchar *names[3];
 222
 223   button->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
 224                                                      GTK_TYPE_LOCK_BUTTON,
 225                                                      GtkLockButtonPrivate);
 226
 227   priv->label_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
 228   priv->box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
 229   gtk_widget_set_halign (priv->box, GTK_ALIGN_CENTER);
 230   gtk_widget_set_valign (priv->box, GTK_ALIGN_CENTER);
 231   gtk_widget_show (priv->box);
 232   gtk_container_add (GTK_CONTAINER (button), priv->box);
 233   priv->image = gtk_image_new ();
 234   gtk_box_pack_start (GTK_BOX (priv->box), priv->image, FALSE, FALSE, 0);
 235   gtk_widget_show (priv->image);
 236   priv->label_lock = gtk_label_new ("");
 237   gtk_misc_set_alignment (GTK_MISC (priv->label_lock), 0, 0.5);
 238   gtk_widget_set_no_show_all (priv->label_lock, TRUE);
 239   gtk_widget_show (priv->label_lock);
 240   gtk_box_pack_start (GTK_BOX (priv->box), priv->label_lock, FALSE, FALSE, 0);
 241   gtk_size_group_add_widget (priv->label_group, priv->label_lock);
 242   priv->label_unlock = gtk_label_new ("");
 243   gtk_misc_set_alignment (GTK_MISC (priv->label_unlock), 0, 0.5);
 244   gtk_widget_set_no_show_all (priv->label_unlock, TRUE);
 245   gtk_box_pack_start (GTK_BOX (priv->box), priv->label_unlock, FALSE, FALSE, 0);
 246   gtk_size_group_add_widget (priv->label_group, priv->label_unlock);
 247
 248   names[0] = "changes-allow-symbolic";
 249   names[1] = "changes-allow";
 250   names[2] = NULL;
 251   priv->icon_unlock = g_themed_icon_new_from_names (names, -1);
 252
 253   names[0] = "changes-prevent-symbolic";
 254   names[1] = "changes-prevent";
 255   names[2] = NULL;
 256   priv->icon_lock = g_themed_icon_new_from_names (names, -1);
 257
 258   update_state (button);
 259 }
 260
 261 static void
 262 gtk_lock_button_class_init (GtkLockButtonClass *klass)
 263 {
 264   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 265   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 266   GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
 267
 268   gobject_class->finalize     = gtk_lock_button_finalize;
 269   gobject_class->get_property = gtk_lock_button_get_property;
 270   gobject_class->set_property = gtk_lock_button_set_property;
 271
 272   button_class->clicked = gtk_lock_button_clicked;
 273
 274   g_type_class_add_private (klass, sizeof (GtkLockButtonPrivate));
 275
 276   g_object_class_install_property (gobject_class, PROP_PERMISSION,
 277     g_param_spec_object ("permission",
 278                          P_("Permission"),
 279                          P_("The GPermission object controlling this button"),
 280                          G_TYPE_PERMISSION,
 281                          G_PARAM_READWRITE |
 282                          G_PARAM_STATIC_STRINGS));
 283
 284   g_object_class_install_property (gobject_class, PROP_TEXT_LOCK,
 285     g_param_spec_string ("text-lock",
 286                          P_("Lock Text"),
 287                          P_("The text to display when prompting the user to lock"),
 288                          _("Lock"),
 289                          G_PARAM_READWRITE |
 290                          G_PARAM_CONSTRUCT |
 291                          G_PARAM_STATIC_STRINGS));
 292
 293   g_object_class_install_property (gobject_class, PROP_TEXT_UNLOCK,
 294     g_param_spec_string ("text-unlock",
 295                          P_("Unlock Text"),
 296                          P_("The text to display when prompting the user to unlock"),
 297                          _("Unlock"),
 298                          G_PARAM_READWRITE |
 299                          G_PARAM_CONSTRUCT |
 300                          G_PARAM_STATIC_STRINGS));
 301
 302   g_object_class_install_property (gobject_class, PROP_TOOLTIP_LOCK,
 303     g_param_spec_string ("tooltip-lock",
 304                          P_("Lock Tooltip"),
 305                          P_("The tooltip to display when prompting the user to lock"),
 306                          _("Dialog is unlocked.\nClick to prevent further changes"),
 307                          G_PARAM_READWRITE |
 308                          G_PARAM_CONSTRUCT |
 309                          G_PARAM_STATIC_STRINGS));
 310
 311   g_object_class_install_property (gobject_class, PROP_TOOLTIP_UNLOCK,
 312     g_param_spec_string ("tooltip-unlock",
 313                          P_("Unlock Tooltip"),
 314                          P_("The tooltip to display when prompting the user to unlock"),
 315                          _("Dialog is locked.\nClick to make changes"),
 316                          G_PARAM_READWRITE |
 317                          G_PARAM_CONSTRUCT |
 318                          G_PARAM_STATIC_STRINGS));
 319
 320   g_object_class_install_property (gobject_class, PROP_TOOLTIP_NOT_AUTHORIZED,
 321     g_param_spec_string ("tooltip-not-authorized",
 322                          P_("Not Authorized Tooltip"),
 323                          P_("The tooltip to display when prompting the user cannot obtain authorization"),
 324                          _("System policy prevents changes.\nContact your system administrator"),
 325                          G_PARAM_READWRITE |
 326                          G_PARAM_CONSTRUCT |
 327                          G_PARAM_STATIC_STRINGS));
 328
 329   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_LOCK_BUTTON_ACCESSIBLE);
 330 }
 331
 332 static void
 333 update_state (GtkLockButton *button)
 334 {
 335   GtkLockButtonPrivate *priv = button->priv;
 336   gboolean allowed;
 337   gboolean can_acquire;
 338   gboolean can_release;
 339   gboolean sensitive;
 340   gboolean visible;
 341   GIcon *icon;
 342   const gchar *tooltip;
 343
 344   if (priv->permission)
 345     {
 346       allowed = g_permission_get_allowed (priv->permission);
 347       can_acquire = g_permission_get_can_acquire (priv->permission);
 348       can_release = g_permission_get_can_release (priv->permission);
 349     }
 350   else
 351     {
 352       allowed = TRUE;
 353       can_acquire = FALSE;
 354       can_release = FALSE;
 355     }
 356
 357   if (allowed && can_release)
 358     {
 359       visible = TRUE;
 360       sensitive = TRUE;
 361       icon = priv->icon_lock;
 362       tooltip = priv->tooltip_lock;
 363     }
 364   else if (allowed && !can_release)
 365     {
 366       visible = FALSE;
 367       sensitive = TRUE;
 368       icon = priv->icon_lock;
 369       tooltip = priv->tooltip_lock;
 370     }
 371   else if (!allowed && can_acquire)
 372     {
 373       visible = TRUE;
 374       sensitive = TRUE;
 375       icon = priv->icon_unlock;
 376       tooltip = priv->tooltip_unlock;
 377     }
 378   else if (!allowed && !can_acquire)
 379     {
 380       visible = TRUE;
 381       sensitive = FALSE;
 382       icon = priv->icon_unlock;
 383       tooltip = priv->tooltip_not_authorized;
 384     }
 385   else
 386     {
 387       g_assert_not_reached ();
 388     }
 389
 390   gtk_image_set_from_gicon (GTK_IMAGE (priv->image), icon, GTK_ICON_SIZE_MENU);
 391   gtk_widget_set_visible (priv->label_lock, allowed);
 392   gtk_widget_set_visible (priv->label_unlock, !allowed);
 393   gtk_widget_set_tooltip_markup (GTK_WIDGET (button), tooltip);
 394   gtk_widget_set_sensitive (GTK_WIDGET (button), sensitive);
 395   gtk_widget_set_visible (GTK_WIDGET (button), visible);
 396 }
 397
 398 static void
 399 on_permission_changed (GPermission *permission,
 400                        GParamSpec  *pspec,
 401                        gpointer     user_data)
 402 {
 403   GtkLockButton *button = GTK_LOCK_BUTTON (user_data);
 404
 405   update_state (button);
 406 }
 407
 408 static void
 409 acquire_cb (GObject      *source,
 410             GAsyncResult *result,
 411             gpointer      user_data)
 412 {
 413   GtkLockButton *button = GTK_LOCK_BUTTON (user_data);
 414   GtkLockButtonPrivate *priv = button->priv;
 415   GError *error;
 416
 417   error = NULL;
 418   if (!g_permission_acquire_finish (priv->permission, result, &error))
 419     {
 420       g_warning ("Error acquiring permission: %s", error->message);
 421       g_error_free (error);
 422     }
 423
 424   g_object_unref (priv->cancellable);
 425   priv->cancellable = NULL;
 426
 427   update_state (button);
 428 }
 429
 430 static void
 431 release_cb (GObject      *source,
 432             GAsyncResult *result,
 433             gpointer      user_data)
 434 {
 435   GtkLockButton *button = GTK_LOCK_BUTTON (user_data);
 436   GtkLockButtonPrivate *priv = button->priv;
 437   GError *error;
 438
 439   error = NULL;
 440   if (!g_permission_release_finish (priv->permission, result, &error))
 441     {
 442       g_warning ("Error releasing permission: %s", error->message);
 443       g_error_free (error);
 444     }
 445
 446   g_object_unref (priv->cancellable);
 447   priv->cancellable = NULL;
 448
 449   update_state (button);
 450 }
 451
 452 static void
 453 gtk_lock_button_clicked (GtkButton *button)
 454 {
 455   GtkLockButtonPrivate *priv = GTK_LOCK_BUTTON (button)->priv;
 456
 457   /* if we already have a pending interactive check, then do nothing */
 458   if (priv->cancellable != NULL)
 459     return;
 460
 461   if (g_permission_get_allowed (priv->permission))
 462     {
 463       if (g_permission_get_can_release (priv->permission))
 464         {
 465           priv->cancellable = g_cancellable_new ();
 466
 467           g_permission_release_async (priv->permission,
 468                                       priv->cancellable,
 469                                       release_cb,
 470                                       button);
 471         }
 472     }
 473   else
 474     {
 475       if (g_permission_get_can_acquire (priv->permission))
 476         {
 477           priv->cancellable = g_cancellable_new ();
 478
 479           g_permission_acquire_async (priv->permission,
 480                                       priv->cancellable,
 481                                       acquire_cb,
 482                                       button);
 483         }
 484     }
 485 }
 486
 487 /**
 488  * gtk_lock_button_new:
 489  * @permission: (allow-none): a #GPermission
 490  *
 491  * Creates a new lock button which reflects the @permission.
 492  *
 493  * Returns: a new #GtkLockButton
 494  *
 495  * Since: 3.2
 496  */
 497 GtkWidget *
 498 gtk_lock_button_new (GPermission *permission)
 499 {
 500   return GTK_WIDGET (g_object_new (GTK_TYPE_LOCK_BUTTON,
 501                                    "permission", permission,
 502                                    NULL));
 503 }
 504
 505 /**
 506  * gtk_lock_button_get_permission:
 507  * @button: a #GtkLockButton
 508  *
 509  * Obtains the #GPermission object that controls @button.
 510  *
 511  * Returns: (transfer none): the #GPermission of @button
 512  *
 513  * Since: 3.2
 514  */
 515 GPermission *
 516 gtk_lock_button_get_permission (GtkLockButton *button)
 517 {
 518   g_return_val_if_fail (GTK_IS_LOCK_BUTTON (button), NULL);
 519
 520   return button->priv->permission;
 521 }
 522
 523 /**
 524  * gtk_lock_button_set_permission:
 525  * @button: a #GtkLockButton
 526  * @permission: (allow-none): a #GPermission object, or %NULL
 527  *
 528  * Sets the #GPermission object that controls @button.
 529  *
 530  * Since: 3.2
 531  */
 532 void
 533 gtk_lock_button_set_permission (GtkLockButton *button,
 534                                 GPermission   *permission)
 535 {
 536   GtkLockButtonPrivate *priv;
 537
 538   g_return_if_fail (GTK_IS_LOCK_BUTTON (button));
 539   g_return_if_fail (permission == NULL || G_IS_PERMISSION (permission));
 540
 541   priv = button->priv;
 542
 543   if (priv->permission != permission)
 544     {
 545       if (priv->permission)
 546         {
 547           g_signal_handlers_disconnect_by_func (priv->permission,
 548                                                 on_permission_changed,
 549                                                 button);
 550           g_object_unref (priv->permission);
 551         }
 552
 553       priv->permission = permission;
 554
 555       if (priv->permission)
 556         {
 557           g_object_ref (priv->permission);
 558           g_signal_connect (priv->permission, "notify",
 559                             G_CALLBACK (on_permission_changed), button);
 560         }
 561
 562       update_state (button);
 563
 564       g_object_notify (G_OBJECT (button), "permission");
 565     }
 566 }
 567
 568 const char *
 569 _gtk_lock_button_get_current_text (GtkLockButton *button)
 570 {
 571   GtkLockButtonPrivate *priv;
 572
 573   g_return_val_if_fail (GTK_IS_LOCK_BUTTON (button), NULL);
 574
 575   priv = button->priv;
 576
 577   if (gtk_widget_get_visible (priv->label_lock))
 578     return gtk_label_get_text (GTK_LABEL (priv->label_lock));
 579   else
 580     return gtk_label_get_text (GTK_LABEL (priv->label_unlock));
 581 }
 582