pidgin/gtkprivacy.c

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