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         PurplePrivacyType type;
  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         treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
 137         *ret_treeview = treeview;
 138
 139         rend = gtk_cell_renderer_text_new();
 140
 141         column = gtk_tree_view_column_new_with_attributes(NULL, rend,
 142                                                                                                           "text", 0,
 143                                                                                                           NULL);
 144         gtk_tree_view_column_set_clickable(GTK_TREE_VIEW_COLUMN(column), TRUE);
 145         gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 146         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
 147         sw = pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, 200);
 148
 149         gtk_widget_show(treeview);
 150
 151         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 152
 153         g_signal_connect(G_OBJECT(sel), "changed",
 154                                          G_CALLBACK(user_selected_cb), dialog);
 155
 156         return sw;
 157 }
 158
 159 static GtkWidget *
 160 build_allow_list(PidginPrivacyDialog *dialog)
 161 {
 162         GtkWidget *widget;
 163         GtkWidget *list;
 164
 165         dialog->allow_store = gtk_list_store_new(1, G_TYPE_STRING);
 166
 167         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->allow_store), 0, GTK_SORT_ASCENDING);
 168
 169         widget = build_list(dialog, dialog->allow_store, &list);
 170
 171         dialog->allow_list = list;
 172
 173         rebuild_allow_list(dialog);
 174
 175         return widget;
 176 }
 177
 178 static GtkWidget *
 179 build_block_list(PidginPrivacyDialog *dialog)
 180 {
 181         GtkWidget *widget;
 182         GtkWidget *list;
 183
 184         dialog->block_store = gtk_list_store_new(1, G_TYPE_STRING);
 185
 186         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->block_store), 0, GTK_SORT_ASCENDING);
 187
 188         widget = build_list(dialog, dialog->block_store, &list);
 189
 190         dialog->block_list = list;
 191
 192         rebuild_block_list(dialog);
 193
 194         return widget;
 195 }
 196
 197 static gint
 198 destroy_cb(GtkWidget *w, GdkEvent *event, PidginPrivacyDialog *dialog)
 199 {
 200         pidgin_privacy_dialog_hide();
 201
 202         return 0;
 203 }
 204
 205 static void
 206 select_account_cb(GtkWidget *dropdown, PurpleAccount *account,
 207                                   PidginPrivacyDialog *dialog)
 208 {
 209         gsize i;
 210
 211         dialog->account = account;
 212
 213         for (i = 0; i < menu_entry_count; i++) {
 214                 if (menu_entries[i].type == account->perm_deny) {
 215                         gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), i);
 216                         break;
 217                 }
 218         }
 219
 220         rebuild_allow_list(dialog);
 221         rebuild_block_list(dialog);
 222 }
 223
 224 /*
 225  * TODO: Setting the permit/deny setting needs to go through privacy.c
 226  *       Even better: the privacy API needs to not suck.
 227  */
 228 static void
 229 type_changed_cb(GtkComboBox *combo, PidginPrivacyDialog *dialog)
 230 {
 231         PurplePrivacyType new_type =
 232                 menu_entries[gtk_combo_box_get_active(combo)].type;
 233
 234         dialog->account->perm_deny = new_type;
 235         serv_set_permit_deny(purple_account_get_connection(dialog->account));
 236
 237         gtk_widget_hide(dialog->allow_widget);
 238         gtk_widget_hide(dialog->block_widget);
 239         gtk_widget_hide_all(dialog->button_box);
 240
 241         if (new_type == PURPLE_PRIVACY_ALLOW_USERS) {
 242                 gtk_widget_show(dialog->allow_widget);
 243                 gtk_widget_show_all(dialog->button_box);
 244                 dialog->in_allow_list = TRUE;
 245         }
 246         else if (new_type == PURPLE_PRIVACY_DENY_USERS) {
 247                 gtk_widget_show(dialog->block_widget);
 248                 gtk_widget_show_all(dialog->button_box);
 249                 dialog->in_allow_list = FALSE;
 250         }
 251
 252         gtk_widget_show_all(dialog->close_button);
 253         gtk_widget_show(dialog->button_box);
 254
 255         purple_blist_schedule_save();
 256         pidgin_blist_refresh(purple_get_blist());
 257 }
 258
 259 static void
 260 add_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 261 {
 262         if (dialog->in_allow_list)
 263                 pidgin_request_add_permit(dialog->account, NULL);
 264         else
 265                 pidgin_request_add_block(dialog->account, NULL);
 266 }
 267
 268 static void
 269 remove_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 270 {
 271         GtkTreeIter iter;
 272         GtkTreeModel *model;
 273         GtkTreeSelection *sel;
 274         char *name;
 275
 276         if (dialog->in_allow_list && dialog->allow_store == NULL)
 277                 return;
 278
 279         if (!dialog->in_allow_list && dialog->block_store == NULL)
 280                 return;
 281
 282         if (dialog->in_allow_list) {
 283                 model = GTK_TREE_MODEL(dialog->allow_store);
 284                 sel   = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->allow_list));
 285         }
 286         else {
 287                 model = GTK_TREE_MODEL(dialog->block_store);
 288                 sel   = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->block_list));
 289         }
 290
 291         if (gtk_tree_selection_get_selected(sel, NULL, &iter))
 292                 gtk_tree_model_get(model, &iter, 0, &name, -1);
 293         else
 294                 return;
 295
 296         if (dialog->in_allow_list)
 297                 purple_privacy_permit_remove(dialog->account, name, FALSE);
 298         else
 299                 purple_privacy_deny_remove(dialog->account, name, FALSE);
 300
 301         g_free(name);
 302 }
 303
 304 static void
 305 removeall_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 306 {
 307         GSList *l;
 308         if (dialog->in_allow_list)
 309                 l = dialog->account->permit;
 310         else
 311                 l = dialog->account->deny;
 312         while (l) {
 313                 char *user;
 314                 user = l->data;
 315                 l = l->next;
 316                 if (dialog->in_allow_list)
 317                         purple_privacy_permit_remove(dialog->account, user, FALSE);
 318                 else
 319                         purple_privacy_deny_remove(dialog->account, user, FALSE);
 320         }
 321 }
 322
 323 static void
 324 close_cb(GtkWidget *button, PidginPrivacyDialog *dialog)
 325 {
 326         gtk_widget_destroy(dialog->win);
 327
 328         pidgin_privacy_dialog_hide();
 329 }
 330
 331 static PidginPrivacyDialog *
 332 privacy_dialog_new(void)
 333 {
 334         PidginPrivacyDialog *dialog;
 335         GtkWidget *vbox;
 336         GtkWidget *button;
 337         GtkWidget *dropdown;
 338         GtkWidget *label;
 339         gssize selected = -1;
 340         gsize i;
 341
 342         dialog = g_new0(PidginPrivacyDialog, 1);
 343
 344         dialog->win = pidgin_create_dialog(_("Privacy"), PIDGIN_HIG_BORDER, "privacy", TRUE);
 345
 346         g_signal_connect(G_OBJECT(dialog->win), "delete_event",
 347                                          G_CALLBACK(destroy_cb), dialog);
 348
 349         /* Main vbox */
 350         vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog->win), FALSE, PIDGIN_HIG_BORDER);
 351
 352         /* Description label */
 353         label = gtk_label_new(
 354                 _("Changes to privacy settings take effect immediately."));
 355
 356         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 357         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 358         gtk_widget_show(label);
 359
 360         /* Accounts drop-down */
 361         dropdown = pidgin_account_option_menu_new(NULL, FALSE,
 362                                                                                                 G_CALLBACK(select_account_cb), NULL, dialog);
 363         pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("Set privacy for:"), NULL, dropdown, TRUE, NULL);
 364         dialog->account = pidgin_account_option_menu_get_selected(dropdown);
 365
 366         /* Add the drop-down list with the allow/block types. */
 367         dialog->type_menu = gtk_combo_box_new_text();
 368         gtk_box_pack_start(GTK_BOX(vbox), dialog->type_menu, FALSE, FALSE, 0);
 369         gtk_widget_show(dialog->type_menu);
 370
 371         for (i = 0; i < menu_entry_count; i++) {
 372                 gtk_combo_box_append_text(GTK_COMBO_BOX(dialog->type_menu),
 373                                           _(menu_entries[i].text));
 374
 375                 if (menu_entries[i].type == dialog->account->perm_deny)
 376                         selected = (gssize)i;
 377         }
 378
 379         gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), selected);
 380
 381         g_signal_connect(G_OBJECT(dialog->type_menu), "changed",
 382                                          G_CALLBACK(type_changed_cb), dialog);
 383
 384         /* Build the treeview for the allow list. */
 385         dialog->allow_widget = build_allow_list(dialog);
 386         gtk_box_pack_start(GTK_BOX(vbox), dialog->allow_widget, TRUE, TRUE, 0);
 387
 388         /* Build the treeview for the block list. */
 389         dialog->block_widget = build_block_list(dialog);
 390         gtk_box_pack_start(GTK_BOX(vbox), dialog->block_widget, TRUE, TRUE, 0);
 391
 392         /* Add the button box for Add, Remove, Remove All */
 393         dialog->button_box = pidgin_dialog_get_action_area(GTK_DIALOG(dialog->win));
 394
 395         /* Add button */
 396         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_ADD, G_CALLBACK(add_cb), dialog);
 397         dialog->add_button = button;
 398
 399         /* Remove button */
 400         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_REMOVE, G_CALLBACK(remove_cb), dialog);
 401         dialog->remove_button = button;
 402         /* TODO: This button should be sensitive/invisitive more cleverly */
 403         gtk_widget_set_sensitive(button, FALSE);
 404
 405         /* Remove All button */
 406         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), _("Remove Al_l"), G_CALLBACK(removeall_cb), dialog);
 407         dialog->removeall_button = button;
 408
 409         /* Close button */
 410         button = pidgin_dialog_add_button(GTK_DIALOG(dialog->win), GTK_STOCK_CLOSE, G_CALLBACK(close_cb), dialog);
 411         dialog->close_button = button;
 412
 413         type_changed_cb(GTK_COMBO_BOX(dialog->type_menu), dialog);
 414 #if 0
 415         if (dialog->account->perm_deny == PURPLE_PRIVACY_ALLOW_USERS) {
 416                 gtk_widget_show(dialog->allow_widget);
 417                 gtk_widget_show(dialog->button_box);
 418                 dialog->in_allow_list = TRUE;
 419         }
 420         else if (dialog->account->perm_deny == PURPLE_PRIVACY_DENY_USERS) {
 421                 gtk_widget_show(dialog->block_widget);
 422                 gtk_widget_show(dialog->button_box);
 423                 dialog->in_allow_list = FALSE;
 424         }
 425 #endif
 426         return dialog;
 427 }
 428
 429 void
 430 pidgin_privacy_dialog_show(void)
 431 {
 432         g_return_if_fail(purple_connections_get_all() != NULL);
 433
 434         if (privacy_dialog == NULL)
 435                 privacy_dialog = privacy_dialog_new();
 436
 437         gtk_widget_show(privacy_dialog->win);
 438         gdk_window_raise(privacy_dialog->win->window);
 439 }
 440
 441 void
 442 pidgin_privacy_dialog_hide(void)
 443 {
 444         if (privacy_dialog == NULL)
 445                 return;
 446
 447         g_object_unref(G_OBJECT(privacy_dialog->allow_store));
 448         g_object_unref(G_OBJECT(privacy_dialog->block_store));
 449         g_free(privacy_dialog);
 450         privacy_dialog = NULL;
 451 }
 452
 453 static void
 454 destroy_request_data(PidginPrivacyRequestData *data)
 455 {
 456         g_free(data->name);
 457         g_free(data);
 458 }
 459
 460 static void
 461 confirm_permit_block_cb(PidginPrivacyRequestData *data, int option)
 462 {
 463         if (data->block)
 464                 purple_privacy_deny(data->account, data->name, FALSE, FALSE);
 465         else
 466                 purple_privacy_allow(data->account, data->name, FALSE, FALSE);
 467
 468         destroy_request_data(data);
 469 }
 470
 471 static void
 472 add_permit_block_cb(PidginPrivacyRequestData *data, const char *name)
 473 {
 474         data->name = g_strdup(name);
 475
 476         confirm_permit_block_cb(data, 0);
 477 }
 478
 479 void
 480 pidgin_request_add_permit(PurpleAccount *account, const char *name)
 481 {
 482         PidginPrivacyRequestData *data;
 483
 484         g_return_if_fail(account != NULL);
 485
 486         data = g_new0(PidginPrivacyRequestData, 1);
 487         data->account = account;
 488         data->name    = g_strdup(name);
 489         data->block   = FALSE;
 490
 491         if (name == NULL) {
 492                 purple_request_input(account, _("Permit User"),
 493                         _("Type a user you permit to contact you."),
 494                         _("Please enter the name of the user you wish to be "
 495                           "able to contact you."),
 496                         NULL, FALSE, FALSE, NULL,
 497                         _("_Permit"), G_CALLBACK(add_permit_block_cb),
 498                         _("Cancel"), G_CALLBACK(destroy_request_data),
 499                         account, name, NULL,
 500                         data);
 501         }
 502         else {
 503                 char *primary = g_strdup_printf(_("Allow %s to contact you?"), name);
 504                 char *secondary =
 505                         g_strdup_printf(_("Are you sure you wish to allow "
 506                                                           "%s to contact you?"), name);
 507
 508
 509                 purple_request_action(account, _("Permit User"), primary, secondary,
 510                                                         0,
 511                                                         account, name, NULL,
 512                                                         data, 2,
 513                                                         _("_Permit"), G_CALLBACK(confirm_permit_block_cb),
 514                                                         _("Cancel"), G_CALLBACK(destroy_request_data));
 515
 516                 g_free(primary);
 517                 g_free(secondary);
 518         }
 519 }
 520
 521 void
 522 pidgin_request_add_block(PurpleAccount *account, const char *name)
 523 {
 524         PidginPrivacyRequestData *data;
 525
 526         g_return_if_fail(account != NULL);
 527
 528         data = g_new0(PidginPrivacyRequestData, 1);
 529         data->account = account;
 530         data->name    = g_strdup(name);
 531         data->block   = TRUE;
 532
 533         if (name == NULL) {
 534                 purple_request_input(account, _("Block User"),
 535                         _("Type a user to block."),
 536                         _("Please enter the name of the user you wish to block."),
 537                         NULL, FALSE, FALSE, NULL,
 538                         _("_Block"), G_CALLBACK(add_permit_block_cb),
 539                         _("Cancel"), G_CALLBACK(destroy_request_data),
 540                         account, name, NULL,
 541                         data);
 542         }
 543         else {
 544                 char *primary = g_strdup_printf(_("Block %s?"), name);
 545                 char *secondary =
 546                         g_strdup_printf(_("Are you sure you want to block %s?"), name);
 547
 548                 purple_request_action(account, _("Block User"), primary, secondary,
 549                                                         0,
 550                                                         account, name, NULL,
 551                                                         data, 2,
 552                                                         _("_Block"), G_CALLBACK(confirm_permit_block_cb),
 553                                                         _("Cancel"), G_CALLBACK(destroy_request_data));
 554
 555                 g_free(primary);
 556                 g_free(secondary);
 557         }
 558 }
 559
 560 static void
 561 pidgin_permit_added_removed(PurpleAccount *account, const char *name)
 562 {
 563         if (privacy_dialog != NULL)
 564                 rebuild_allow_list(privacy_dialog);
 565 }
 566
 567 static void
 568 pidgin_deny_added_removed(PurpleAccount *account, const char *name)
 569 {
 570         if (privacy_dialog != NULL)
 571                 rebuild_block_list(privacy_dialog);
 572 }
 573
 574 static PurplePrivacyUiOps privacy_ops =
 575 {
 576         pidgin_permit_added_removed,
 577         pidgin_permit_added_removed,
 578         pidgin_deny_added_removed,
 579         pidgin_deny_added_removed,
 580         NULL,
 581         NULL,
 582         NULL,
 583         NULL
 584 };
 585
 586 PurplePrivacyUiOps *
 587 pidgin_privacy_get_ui_ops(void)
 588 {
 589         return &privacy_ops;
 590 }
 591
 592 void
 593 pidgin_privacy_init(void)
 594 {
 595 }