pidgin/gtkprivacy.c

   1 /* pidgin
   2  *
   3  * Pidgin is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21 #include "internal.h"
  22 #include "pidgin.h"
  23
  24 #include "connection.h"
  25 #include "debug.h"
  26 #include "request.h"
  27 #include "util.h"
  28
  29 #include "gtkaccount.h"
  30 #include "gtkblist.h"
  31 #include "gtkprivacy.h"
  32 #include "gtkutils.h"
  33
  34 #include "gtk3compat.h"
  35
  36 typedef struct
  37 {
  38         GtkWidget *win;
  39
  40         GtkWidget *type_menu;
  41
  42         GtkWidget *add_button;
  43         GtkWidget *remove_button;
  44         GtkWidget *removeall_button;
  45         GtkWidget *close_button;
  46
  47         GtkWidget *button_box;
  48         GtkWidget *allow_widget;
  49         GtkWidget *block_widget;
  50
  51         GtkListStore *allow_store;
  52         GtkListStore *block_store;
  53
  54         GtkWidget *allow_list;
  55         GtkWidget *block_list;
  56
  57         gboolean in_allow_list;
  58
  59         PurpleAccount *account;
  60
  61 } PidginPrivacyDialog;
  62
  63 typedef struct
  64 {
  65         PurpleAccount *account;
  66         char *name;
  67         gboolean block;
  68
  69 } PidginPrivacyRequestData;
  70
  71 static struct
  72 {
  73         const char *text;
  74         PurpleAccountPrivacyType type;
  75
  76 } const menu_entries[] =
  77 {
  78         { N_("Allow all users to contact me"),         PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL },
  79         { N_("Allow only the users on my buddy list"), PURPLE_ACCOUNT_PRIVACY_ALLOW_BUDDYLIST },
  80         { N_("Allow only the users below"),            PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS },
  81         { N_("Block all users"),                       PURPLE_ACCOUNT_PRIVACY_DENY_ALL },
  82         { N_("Block only the users below"),            PURPLE_ACCOUNT_PRIVACY_DENY_USERS }
  83 };
  84
  85 static const size_t menu_entry_count = sizeof(menu_entries) / sizeof(*menu_entries);
  86
  87 static PidginPrivacyDialog *privacy_dialog = NULL;
  88
  89 static void
  90 rebuild_allow_list(PidginPrivacyDialog *dialog)
  91 {
  92         GSList *l;
  93         GtkTreeIter iter;
  94
  95         gtk_list_store_clear(dialog->allow_store);
  96
  97         for (l = purple_account_privacy_get_permitted(dialog->account); l != NULL; l = l->next) {
  98                 gtk_list_store_append(dialog->allow_store, &iter);
  99                 gtk_list_store_set(dialog->allow_store, &iter, 0, l->data, -1);
 100         }
 101 }
 102
 103 static void
 104 rebuild_block_list(PidginPrivacyDialog *dialog)
 105 {
 106         GSList *l;
 107         GtkTreeIter iter;
 108
 109         gtk_list_store_clear(dialog->block_store);
 110
 111         for (l = purple_account_privacy_get_denied(dialog->account); l != NULL; l = l->next) {
 112                 gtk_list_store_append(dialog->block_store, &iter);
 113                 gtk_list_store_set(dialog->block_store, &iter, 0, l->data, -1);
 114         }
 115 }
 116
 117 static void
 118 user_selected_cb(GtkTreeSelection *sel, PidginPrivacyDialog *dialog)
 119 {
 120         gtk_widget_set_sensitive(dialog->remove_button, TRUE);
 121 }
 122
 123 static GtkWidget *
 124 build_list(PidginPrivacyDialog *dialog, GtkListStore *model,
 125                    GtkWidget **ret_treeview)
 126 {
 127         GtkWidget *sw;
 128         GtkWidget *treeview;
 129         GtkCellRenderer *rend;
 130         GtkTreeViewColumn *column;
 131         GtkTreeSelection *sel;
 132
 133         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
 134         *ret_treeview = treeview;
 135
 136         rend = gtk_cell_renderer_text_new();
 137
 138         column = gtk_tree_view_column_new_with_attributes(NULL, rend,
 139                                                                                                           "text", 0,
 140                                                                                                           NULL);
 141         gtk_tree_view_column_set_clickable(GTK_TREE_VIEW_COLUMN(column), TRUE);
 142         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 143         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
 144         sw = pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, 200);
 145
 146         gtk_widget_show(treeview);
 147
 148         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 149
 150         g_signal_connect(G_OBJECT(sel), "changed",
 151                                          G_CALLBACK(user_selected_cb), dialog);
 152
 153         return sw;
 154 }
 155
 156 static GtkWidget *
 157 build_allow_list(PidginPrivacyDialog *dialog)
 158 {
 159         GtkWidget *widget;
 160         GtkWidget *list;
 161
 162         dialog->allow_store = gtk_list_store_new(1, G_TYPE_STRING);
 163
 164         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->allow_store), 0, GTK_SORT_ASCENDING);
 165
 166         widget = build_list(dialog, dialog->allow_store, &list);
 167
 168         dialog->allow_list = list;
 169
 170         rebuild_allow_list(dialog);
 171
 172         return widget;
 173 }
 174
 175 static GtkWidget *
 176 build_block_list(PidginPrivacyDialog *dialog)
 177 {
 178         GtkWidget *widget;
 179         GtkWidget *list;
 180
 181         dialog->block_store = gtk_list_store_new(1, G_TYPE_STRING);
 182
 183         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->block_store), 0, GTK_SORT_ASCENDING);
 184
 185         widget = build_list(dialog, dialog->block_store, &list);
 186
 187         dialog->block_list = list;
 188
 189         rebuild_block_list(dialog);
 190
 191         return widget;
 192 }
 193
 194 static gint
 195 destroy_cb(GtkWidget *w, GdkEvent *event, PidginPrivacyDialog *dialog)
 196 {
 197         pidgin_privacy_dialog_hide();
 198
 199         return 0;
 200 }
 201
 202 static void
 203 select_account_cb(GtkWidget *dropdown, PurpleAccount *account,
 204                                   PidginPrivacyDialog *dialog)
 205 {
 206         gsize i;
 207
 208         dialog->account = account;
 209
 210         for (i = 0; i < menu_entry_count; i++) {
 211                 if (menu_entries[i].type == purple_account_get_privacy_type(account)) {
 212                         gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), i);
 213                         break;
 214                 }
 215         }
 216
 217         rebuild_allow_list(dialog);
 218         rebuild_block_list(dialog);
 219 }
 220
 221 /*
 222  * TODO: Setting the permit/deny setting needs to go through privacy.c
 223  *       Even better: the privacy API needs to not suck.
 224  */
 225 static void
 226 type_changed_cb(GtkComboBox *combo, PidginPrivacyDialog *dialog)
 227 {
 228         PurpleAccountPrivacyType new_type =
 229                 menu_entries[gtk_combo_box_get_active(combo)].type;
 230
 231         purple_account_set_privacy_type(dialog->account, new_type);
 232         purple_serv_set_permit_deny(purple_account_get_connection(dialog->account));
 233
 234         gtk_widget_hide(dialog->allow_widget);
 235         gtk_widget_hide(dialog->block_widget);
 236         gtk_widget_hide(dialog->button_box);
 237
 238         if (new_type == PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS) {
 239                 gtk_widget_show(dialog->allow_widget);
 240                 gtk_widget_show_all(dialog->button_box);
 241                 dialog->in_allow_list = TRUE;
 242         }
 243         else if (new_type == PURPLE_ACCOUNT_PRIVACY_DENY_USERS) {
 244                 gtk_widget_show(dialog->block_widget);
 245                 gtk_widget_show_all(dialog->button_box);
 246                 dialog->in_allow_list = FALSE;
 247         }
 248
 249         gtk_widget_show_all(dialog->close_button);
 250         gtk_widget_show(dialog->button_box);
 251
 252         purple_blist_schedule_save();
 253         pidgin_blist_refresh(purple_blist_get_buddy_list());
 254 }
 255
 256 static void
 257 add_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 258 {
 259         if (dialog->in_allow_list)
 260                 pidgin_request_add_permit(dialog->account, NULL);
 261         else
 262                 pidgin_request_add_block(dialog->account, NULL);
 263 }
 264
 265 static void
 266 remove_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 267 {
 268         GtkTreeIter iter;
 269         GtkTreeModel *model;
 270         GtkTreeSelection *sel;
 271         char *name;
 272
 273         if (dialog->in_allow_list && dialog->allow_store == NULL)
 274                 return;
 275
 276         if (!dialog->in_allow_list && dialog->block_store == NULL)
 277                 return;
 278
 279         if (dialog->in_allow_list) {
 280                 model = GTK_TREE_MODEL(dialog->allow_store);
 281                 sel   = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->allow_list));
 282         }
 283         else {
 284                 model = GTK_TREE_MODEL(dialog->block_store);
 285                 sel   = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->block_list));
 286         }
 287
 288         if (gtk_tree_selection_get_selected(sel, NULL, &iter))
 289                 gtk_tree_model_get(model, &iter, 0, &name, -1);
 290         else
 291                 return;
 292
 293         if (dialog->in_allow_list)
 294                 purple_account_privacy_permit_remove(dialog->account, name, FALSE);
 295         else
 296                 purple_account_privacy_deny_remove(dialog->account, name, FALSE);
 297
 298         g_free(name);
 299 }
 300
 301 static void
 302 removeall_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 303 {
 304         GSList *l;
 305         if (dialog->in_allow_list)
 306                 l = purple_account_privacy_get_permitted(dialog->account);
 307         else
 308                 l = purple_account_privacy_get_denied(dialog->account);
 309         while (l) {
 310                 char *user;
 311                 user = l->data;
 312                 l = l->next;
 313                 if (dialog->in_allow_list)
 314                         purple_account_privacy_permit_remove(dialog->account, user, FALSE);
 315                 else
 316                         purple_account_privacy_deny_remove(dialog->account, user, FALSE);
 317         }
 318 }
 319
 320 static void
 321 close_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 322 {
 323         gtk_widget_destroy(dialog->win);
 324
 325         pidgin_privacy_dialog_hide();
 326 }
 327
 328 static PidginPrivacyDialog *
 329 privacy_dialog_new(void)
 330 {
 331         PidginPrivacyDialog *dialog;
 332         GtkWidget *vbox;
 333         GtkWidget *button;
 334         GtkWidget *dropdown;
 335         GtkWidget *label;
 336         gssize selected = -1;
 337         gsize i;
 338
 339         dialog = g_new0(PidginPrivacyDialog, 1);
 340
 341         dialog->win = pidgin_create_dialog(_("Privacy"), PIDGIN_HIG_BORDER, "privacy", TRUE);
 342
 343         g_signal_connect(G_OBJECT(dialog->win), "delete_event",
 344                                          G_CALLBACK(destroy_cb), dialog);
 345
 346         /* Main vbox */
 347         vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog->win), FALSE, PIDGIN_HIG_BORDER);
 348
 349         /* Description label */
 350         label = gtk_label_new(
 351                 _("Changes to privacy settings take effect immediately."));
 352
 353         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 354         gtk_label_set_xalign(GTK_LABEL(label), 0);
 355         gtk_widget_show(label);
 356
 357         /* Accounts drop-down */
 358         dropdown = pidgin_account_option_menu_new(NULL, FALSE,
 359                                                                                                 G_CALLBACK(select_account_cb), NULL, dialog);
 360         pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Set privacy for:"), NULL, dropdown, TRUE, NULL);
 361         dialog->account = pidgin_account_option_menu_get_selected(dropdown);
 362
 363         /* Add the drop-down list with the allow/block types. */
 364         dialog->type_menu = gtk_combo_box_text_new();
 365         gtk_box_pack_start(GTK_BOX(vbox), dialog->type_menu, FALSE, FALSE, 0);
 366         gtk_widget_show(dialog->type_menu);
 367
 368         for (i = 0; i < menu_entry_count; i++) {
 369                 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(dialog->type_menu),
 370                                           _(menu_entries[i].text));
 371
 372                 if (menu_entries[i].type == purple_account_get_privacy_type(dialog->account))
 373                         selected = (gssize)i;
 374         }
 375
 376         gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), selected);
 377
 378         g_signal_connect(G_OBJECT(dialog->type_menu), "changed",
 379                                          G_CALLBACK(type_changed_cb), dialog);
 380
 381         /* Build the treeview for the allow list. */
 382         dialog->allow_widget = build_allow_list(dialog);
 383         gtk_box_pack_start(GTK_BOX(vbox), dialog->allow_widget, TRUE, TRUE, 0);
 384
 385         /* Build the treeview for the block list. */
 386         dialog->block_widget = build_block_list(dialog);
 387         gtk_box_pack_start(GTK_BOX(vbox), dialog->block_widget, TRUE, TRUE, 0);
 388
 389         /* Add the button box for Add, Remove, Remove All */
 390         dialog->button_box = pidgin_dialog_get_action_area(GTK_DIALOG(dialog->win));
 391
 392         /* Add button */
 393         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_ADD, G_CALLBACK(add_cb), dialog);
 394         dialog->add_button = button;
 395
 396         /* Remove button */
 397         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_REMOVE, G_CALLBACK(remove_cb), dialog);
 398         dialog->remove_button = button;
 399         /* TODO: This button should be sensitive/invisitive more cleverly */
 400         gtk_widget_set_sensitive(button, FALSE);
 401
 402         /* Remove All button */
 403         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), _("Remove Al_l"), G_CALLBACK(removeall_cb), dialog);
 404         dialog->removeall_button = button;
 405
 406         /* Close button */
 407         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_CLOSE, G_CALLBACK(close_cb), dialog);
 408         dialog->close_button = button;
 409
 410         type_changed_cb(GTK_COMBO_BOX(dialog->type_menu), dialog);
 411 #if 0
 412         if (purple_account_get_privacy_type(dialog->account) == PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS) {
 413                 gtk_widget_show(dialog->allow_widget);
 414                 gtk_widget_show(dialog->button_box);
 415                 dialog->in_allow_list = TRUE;
 416         }
 417         else if (purple_account_get_privacy_type(dialog->account) == PURPLE_ACCOUNT_PRIVACY_DENY_USERS) {
 418                 gtk_widget_show(dialog->block_widget);
 419                 gtk_widget_show(dialog->button_box);
 420                 dialog->in_allow_list = FALSE;
 421         }
 422 #endif
 423         return dialog;
 424 }
 425
 426 void
 427 pidgin_privacy_dialog_show(void)
 428 {
 429         g_return_if_fail(purple_connections_get_all() != NULL);
 430
 431         if (privacy_dialog == NULL)
 432                 privacy_dialog = privacy_dialog_new();
 433
 434         gtk_widget_show(privacy_dialog->win);
 435         gdk_window_raise(gtk_widget_get_window(privacy_dialog->win));
 436 }
 437
 438 void
 439 pidgin_privacy_dialog_hide(void)
 440 {
 441         if (privacy_dialog == NULL)
 442                 return;
 443
 444         g_object_unref(G_OBJECT(privacy_dialog->allow_store));
 445         g_object_unref(G_OBJECT(privacy_dialog->block_store));
 446         g_free(privacy_dialog);
 447         privacy_dialog = NULL;
 448 }
 449
 450 static void
 451 destroy_request_data(PidginPrivacyRequestData *data)
 452 {
 453         g_free(data->name);
 454         g_free(data);
 455 }
 456
 457 static void
 458 confirm_permit_block_cb(PidginPrivacyRequestData *data, int option)
 459 {
 460         if (data->block)
 461                 purple_account_privacy_deny(data->account, data->name);
 462         else
 463                 purple_account_privacy_allow(data->account, data->name);
 464
 465         destroy_request_data(data);
 466 }
 467
 468 static void
 469 add_permit_block_cb(PidginPrivacyRequestData *data, const char *name)
 470 {
 471         data->name = g_strdup(name);
 472
 473         confirm_permit_block_cb(data, 0);
 474 }
 475
 476 void
 477 pidgin_request_add_permit(PurpleAccount *account, const char *name)
 478 {
 479         PidginPrivacyRequestData *data;
 480
 481         g_return_if_fail(account != NULL);
 482
 483         data = g_new0(PidginPrivacyRequestData, 1);
 484         data->account = account;
 485         data->name    = g_strdup(name);
 486         data->block   = FALSE;
 487
 488         if (name == NULL) {
 489                 purple_request_input(account, _("Permit User"),
 490                         _("Type a user you permit to contact you."),
 491                         _("Please enter the name of the user you wish to be "
 492                           "able to contact you."),
 493                         NULL, FALSE, FALSE, NULL,
 494                         _("_Permit"), G_CALLBACK(add_permit_block_cb),
 495                         _("Cancel"), G_CALLBACK(destroy_request_data),
 496                         purple_request_cpar_from_account(account),
 497                         data);
 498         }
 499         else {
 500                 char *primary = g_strdup_printf(_("Allow %s to contact you?"), name);
 501                 char *secondary =
 502                         g_strdup_printf(_("Are you sure you wish to allow "
 503                                                           "%s to contact you?"), name);
 504
 505
 506                 purple_request_action(account, _("Permit User"), primary,
 507                         secondary, 0, purple_request_cpar_from_account(account),
 508                         data, 2,
 509                         _("_Permit"), G_CALLBACK(confirm_permit_block_cb),
 510                         _("Cancel"), G_CALLBACK(destroy_request_data));
 511
 512                 g_free(primary);
 513                 g_free(secondary);
 514         }
 515 }
 516
 517 void
 518 pidgin_request_add_block(PurpleAccount *account, const char *name)
 519 {
 520         PidginPrivacyRequestData *data;
 521
 522         g_return_if_fail(account != NULL);
 523
 524         data = g_new0(PidginPrivacyRequestData, 1);
 525         data->account = account;
 526         data->name    = g_strdup(name);
 527         data->block   = TRUE;
 528
 529         if (name == NULL) {
 530                 purple_request_input(account, _("Block User"),
 531                         _("Type a user to block."),
 532                         _("Please enter the name of the user you wish to block."),
 533                         NULL, FALSE, FALSE, NULL,
 534                         _("_Block"), G_CALLBACK(add_permit_block_cb),
 535                         _("Cancel"), G_CALLBACK(destroy_request_data),
 536                         purple_request_cpar_from_account(account),
 537                         data);
 538         }
 539         else {
 540                 char *primary = g_strdup_printf(_("Block %s?"), name);
 541                 char *secondary =
 542                         g_strdup_printf(_("Are you sure you want to block %s?"), name);
 543
 544                 purple_request_action(account, _("Block User"), primary,
 545                         secondary, 0, purple_request_cpar_from_account(account),
 546                         data, 2,
 547                         _("_Block"), G_CALLBACK(confirm_permit_block_cb),
 548                         _("Cancel"), G_CALLBACK(destroy_request_data));
 549
 550                 g_free(primary);
 551                 g_free(secondary);
 552         }
 553 }
 554
 555 static void
 556 pidgin_permit_added_removed(PurpleAccount *account, const char *name)
 557 {
 558         if (privacy_dialog != NULL)
 559                 rebuild_allow_list(privacy_dialog);
 560 }
 561
 562 static void
 563 pidgin_deny_added_removed(PurpleAccount *account, const char *name)
 564 {
 565         if (privacy_dialog != NULL)
 566                 rebuild_block_list(privacy_dialog);
 567 }
 568
 569 void
 570 pidgin_privacy_init(void)
 571 {
 572         PurpleAccountUiOps *ops = pidgin_accounts_get_ui_ops();
 573
 574         ops->permit_added = ops->permit_removed = pidgin_permit_added_removed;
 575         ops->deny_added = ops->deny_removed = pidgin_deny_added_removed;
 576 }