libempathy-gtk/empathy-individual-menu.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2008-2010 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 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  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Xavier Claessens <xclaesse@gmail.com>
  20  *          Travis Reitter <travis.reitter@collabora.co.uk>
  21  */
  22
  23 #include "config.h"
  24 #include "empathy-individual-menu.h"
  25
  26 #include <glib/gi18n-lib.h>
  27 #include <tp-account-widgets/tpaw-camera-monitor.h>
  28
  29 #include "empathy-account-selector-dialog.h"
  30 #include "empathy-call-utils.h"
  31 #include "empathy-chatroom-manager.h"
  32 #include "empathy-gtk-enum-types.h"
  33 #include "empathy-images.h"
  34 #include "empathy-individual-dialogs.h"
  35 #include "empathy-individual-dialogs.h"
  36 #include "empathy-individual-edit-dialog.h"
  37 #include "empathy-individual-information-dialog.h"
  38 #include "empathy-individual-manager.h"
  39 #include "empathy-individual-store-channel.h"
  40 #include "empathy-log-window.h"
  41 #include "empathy-request-util.h"
  42 #include "empathy-share-my-desktop.h"
  43 #include "empathy-ui-utils.h"
  44 #include "empathy-utils.h"
  45
  46 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  47 #include "empathy-debug.h"
  48
  49 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualMenu)
  50
  51 typedef struct {
  52   gchar *active_group; /* may be NULL */
  53   FolksIndividual *individual; /* owned */
  54   EmpathyIndividualFeatureFlags features;
  55   EmpathyIndividualStore *store; /* may be NULL */
  56 } EmpathyIndividualMenuPriv;
  57
  58 enum {
  59   PROP_ACTIVE_GROUP = 1,
  60   PROP_INDIVIDUAL,
  61   PROP_FEATURES,
  62   PROP_STORE,
  63 };
  64
  65 enum {
  66   MENU_ITEM_ACTIVATED,
  67   LAST_SIGNAL
  68 };
  69
  70 static guint signals [LAST_SIGNAL] = { 0 };
  71
  72 G_DEFINE_TYPE (EmpathyIndividualMenu, empathy_individual_menu, GTK_TYPE_MENU);
  73
  74 static GtkWidget * empathy_individual_chat_menu_item_new (
  75     FolksIndividual *individual);
  76 static GtkWidget * empathy_individual_sms_menu_item_new (
  77     FolksIndividual *individual);
  78 static GtkWidget * empathy_individual_log_menu_item_new  (
  79     FolksIndividual *individual);
  80 static GtkWidget * empathy_individual_info_menu_item_new (
  81     FolksIndividual *individual);
  82 static GtkWidget * empathy_individual_edit_menu_item_new (
  83     FolksIndividual *individual);
  84 static GtkWidget * empathy_individual_invite_menu_item_new (
  85     FolksIndividual *individual,
  86     EmpathyContact *contact);
  87 static GtkWidget * empathy_individual_file_transfer_menu_item_new (
  88     FolksIndividual *individual);
  89 static GtkWidget * empathy_individual_share_my_desktop_menu_item_new (
  90     FolksIndividual *individual);
  91 static GtkWidget * empathy_individual_favourite_menu_item_new (
  92     FolksIndividual *individual);
  93 static GtkWidget * empathy_individual_add_menu_item_new (
  94     EmpathyIndividualMenu *self,
  95     FolksIndividual *individual);
  96 static GtkWidget * empathy_individiual_block_menu_item_new (
  97     FolksIndividual *individual);
  98 static GtkWidget * empathy_individiual_remove_menu_item_new (
  99     EmpathyIndividualMenu *self);
 100
 101 static void
 102 individual_menu_add_personas (GtkMenuShell *menu,
 103     FolksIndividual *individual,
 104     EmpathyIndividualFeatureFlags features)
 105 {
 106   GtkWidget *item;
 107   GeeSet *personas;
 108   GeeIterator *iter;
 109   guint persona_count = 0;
 110
 111   g_return_if_fail (GTK_IS_MENU (menu));
 112   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
 113   g_return_if_fail (empathy_folks_individual_contains_contact (individual));
 114
 115   personas = folks_individual_get_personas (individual);
 116   /* we'll re-use this iterator throughout */
 117   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 118
 119   /* Make sure we've got enough valid entries for these menu items to add
 120    * functionality */
 121   while (gee_iterator_next (iter))
 122     {
 123       FolksPersona *persona = gee_iterator_get (iter);
 124       if (empathy_folks_persona_is_interesting (persona))
 125         persona_count++;
 126
 127       g_clear_object (&persona);
 128     }
 129
 130   /* return early if these entries would add nothing beyond the "quick" items */
 131   if (persona_count <= 1)
 132     goto out;
 133
 134   /* add a separator before the list of personas */
 135   item = gtk_separator_menu_item_new ();
 136   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 137   gtk_widget_show (item);
 138
 139   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 140   while (gee_iterator_next (iter))
 141     {
 142       GtkWidget *image;
 143       GtkWidget *contact_item;
 144       GtkWidget *contact_submenu;
 145       TpContact *tp_contact;
 146       EmpathyContact *contact;
 147       TpfPersona *persona = gee_iterator_get (iter);
 148       gchar *label;
 149       FolksPersonaStore *store;
 150       const gchar *account;
 151       GtkWidget *action;
 152       /* Individual containing only persona */
 153       FolksIndividual *single_individual;
 154
 155       if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
 156         goto while_finish;
 157
 158       tp_contact = tpf_persona_get_contact (persona);
 159       if (tp_contact == NULL)
 160         goto while_finish;
 161
 162       contact = empathy_contact_dup_from_tp_contact (tp_contact);
 163       single_individual = empathy_create_individual_from_tp_contact (
 164           tp_contact);
 165
 166       /* Pretty hacky. Creating single_individual had a side effect to change
 167        * persona.individual from individual to single_individual which is not
 168        * what we want so we set it back. See bgo#684971 for details. */
 169       g_object_set (persona, "individual", individual, NULL);
 170
 171       store = folks_persona_get_store (FOLKS_PERSONA (persona));
 172       account = folks_persona_store_get_display_name (store);
 173
 174       /* Translators: this is used in the context menu for a contact. The first
 175        * parameter is a contact ID (e.g. foo@jabber.org) and the second is one
 176        * of the user's account IDs (e.g. me@hotmail.com). */
 177       label = g_strdup_printf (_("%s (%s)"),
 178           folks_persona_get_display_id (FOLKS_PERSONA (persona)), account);
 179
 180       contact_item = gtk_image_menu_item_new_with_label (label);
 181       gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (contact_item),
 182                                                  TRUE);
 183       contact_submenu = gtk_menu_new ();
 184       gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_item), contact_submenu);
 185       image = gtk_image_new_from_icon_name (
 186           empathy_icon_name_for_contact (contact), GTK_ICON_SIZE_MENU);
 187       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (contact_item), image);
 188       gtk_widget_show (image);
 189
 190       /* Chat */
 191       if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
 192         {
 193           action = empathy_individual_chat_menu_item_new (single_individual);
 194           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 195           gtk_widget_show (action);
 196         }
 197
 198       /* SMS */
 199       if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS)
 200         {
 201           action = empathy_individual_sms_menu_item_new (single_individual);
 202           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 203           gtk_widget_show (action);
 204         }
 205
 206       if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
 207         {
 208           /* Audio Call */
 209           action = empathy_individual_audio_call_menu_item_new (
 210               single_individual);
 211           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 212           gtk_widget_show (action);
 213
 214           /* Video Call */
 215           action = empathy_individual_video_call_menu_item_new (
 216               single_individual);
 217           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 218           gtk_widget_show (action);
 219         }
 220
 221       /* Log */
 222       if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
 223         {
 224           action = empathy_individual_log_menu_item_new (single_individual);
 225           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 226           gtk_widget_show (action);
 227         }
 228
 229       /* Invite */
 230       action = empathy_individual_invite_menu_item_new (NULL, contact);
 231       gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 232       gtk_widget_show (action);
 233
 234       /* File transfer */
 235       if (features & EMPATHY_INDIVIDUAL_FEATURE_FILE_TRANSFER)
 236         {
 237           action = empathy_individual_file_transfer_menu_item_new (
 238               single_individual);
 239           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 240           gtk_widget_show (action);
 241         }
 242
 243       /* Share my desktop */
 244       action = empathy_individual_share_my_desktop_menu_item_new (
 245           single_individual);
 246       gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 247       gtk_widget_show (action);
 248
 249       /* Block */
 250       if (features & EMPATHY_INDIVIDUAL_FEATURE_BLOCK &&
 251           (item = empathy_individiual_block_menu_item_new (single_individual))
 252           != NULL) {
 253         GtkWidget *sep;
 254
 255         sep = gtk_separator_menu_item_new ();
 256         gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), sep);
 257         gtk_widget_show (sep);
 258
 259         gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), item);
 260         gtk_widget_show (item);
 261       }
 262
 263       gtk_menu_shell_append (GTK_MENU_SHELL (menu), contact_item);
 264       gtk_widget_show (contact_item);
 265
 266       g_free (label);
 267       g_object_unref (contact);
 268       g_object_unref (single_individual);
 269
 270 while_finish:
 271       g_clear_object (&persona);
 272     }
 273
 274 out:
 275   g_clear_object (&iter);
 276 }
 277
 278 static void
 279 empathy_individual_menu_init (EmpathyIndividualMenu *self)
 280 {
 281   EmpathyIndividualMenuPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 282       EMPATHY_TYPE_INDIVIDUAL_MENU, EmpathyIndividualMenuPriv);
 283
 284   self->priv = priv;
 285 }
 286
 287 static GList *
 288 find_phone_accounts (void)
 289 {
 290   TpAccountManager *am;
 291   GList *accounts, *l;
 292   GList *found = NULL;
 293
 294   am = tp_account_manager_dup ();
 295   g_return_val_if_fail (am != NULL, NULL);
 296
 297   accounts = tp_account_manager_dup_valid_accounts (am);
 298   for (l = accounts; l != NULL; l = g_list_next (l))
 299     {
 300       TpAccount *account = l->data;
 301
 302       if (tp_account_get_connection_status (account, NULL) !=
 303           TP_CONNECTION_STATUS_CONNECTED)
 304         continue;
 305
 306       if (!tp_account_associated_with_uri_scheme (account, "tel"))
 307         continue;
 308
 309       found = g_list_prepend (found, g_object_ref (account));
 310     }
 311
 312   g_list_free_full (accounts, g_object_unref);
 313   g_object_unref (am);
 314
 315   return found;
 316 }
 317
 318 static gboolean
 319 has_phone_account (void)
 320 {
 321   GList *accounts;
 322   gboolean result;
 323
 324   accounts = find_phone_accounts ();
 325   result = (accounts != NULL);
 326
 327   g_list_free_full (accounts, (GDestroyNotify) g_object_unref);
 328
 329   return result;
 330 }
 331
 332 static void
 333 call_phone_number (FolksPhoneFieldDetails *details,
 334     TpAccount *account)
 335 {
 336   DEBUG ("Try to call %s", folks_phone_field_details_get_normalised (details));
 337
 338   empathy_call_new_with_streams (
 339       folks_phone_field_details_get_normalised (details),
 340       account, TRUE, FALSE, empathy_get_current_action_time ());
 341 }
 342
 343 static void
 344 display_call_phone_dialog (FolksPhoneFieldDetails *details,
 345     GList *accounts)
 346 {
 347   GtkWidget *dialog;
 348   gint response;
 349
 350   dialog = empathy_account_selector_dialog_new (accounts);
 351
 352   gtk_window_set_title (GTK_WINDOW (dialog),
 353       _("Select account to use to place the call"));
 354
 355   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 356       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 357       _("Call"), GTK_RESPONSE_OK,
 358       NULL);
 359
 360   response = gtk_dialog_run (GTK_DIALOG (dialog));
 361
 362   if (response == GTK_RESPONSE_OK)
 363     {
 364       TpAccount *account;
 365
 366       account = empathy_account_selector_dialog_dup_selected (
 367            EMPATHY_ACCOUNT_SELECTOR_DIALOG (dialog));
 368
 369       if (account != NULL)
 370         {
 371           call_phone_number (details, account);
 372
 373           g_object_unref (account);
 374         }
 375     }
 376
 377   gtk_widget_destroy (dialog);
 378 }
 379
 380 static void
 381 call_phone_number_cb (GtkMenuItem *item,
 382       FolksPhoneFieldDetails *details)
 383 {
 384   GList *accounts;
 385
 386   accounts = find_phone_accounts ();
 387   if (accounts == NULL)
 388     {
 389       DEBUG ("No phone aware account connected; can't call");
 390     }
 391   else if (g_list_length (accounts) == 1)
 392     {
 393       call_phone_number (details, accounts->data);
 394     }
 395   else
 396     {
 397       /* Ask which account to use */
 398       display_call_phone_dialog (details, accounts);
 399     }
 400
 401   g_list_free_full (accounts, (GDestroyNotify) g_object_unref);
 402 }
 403
 404 static const gchar *
 405 find_phone_type (FolksPhoneFieldDetails *details)
 406 {
 407   GeeCollection *types;
 408   GeeIterator *iter;
 409
 410   types = folks_abstract_field_details_get_parameter_values (
 411       FOLKS_ABSTRACT_FIELD_DETAILS (details), "type");
 412
 413   if (types == NULL)
 414     return NULL;
 415
 416   iter = gee_iterable_iterator (GEE_ITERABLE (types));
 417   while (gee_iterator_next (iter))
 418     {
 419       const gchar *type = gee_iterator_get (iter);
 420
 421       if (!tp_strdiff (type, "CELL"))
 422         return _("Mobile");
 423       else if (!tp_strdiff (type, "WORK"))
 424         return _("Work");
 425       else if (!tp_strdiff (type, "HOME"))
 426         return _("HOME");
 427     }
 428
 429   return NULL;
 430 }
 431
 432 static void
 433 add_phone_numbers (EmpathyIndividualMenu *self)
 434 {
 435   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 436   GeeSet *all_numbers;
 437   GeeIterator *iter;
 438   gboolean sensitive;
 439
 440   all_numbers = folks_phone_details_get_phone_numbers (
 441       FOLKS_PHONE_DETAILS (priv->individual));
 442
 443   sensitive = has_phone_account ();
 444
 445   iter = gee_iterable_iterator (GEE_ITERABLE (all_numbers));
 446   while (gee_iterator_next (iter))
 447     {
 448       FolksPhoneFieldDetails *details = gee_iterator_get (iter);
 449       GtkWidget *item, *image;
 450       gchar *tmp;
 451       const gchar *type;
 452
 453       type = find_phone_type (details);
 454
 455       if (type != NULL)
 456         {
 457           tmp = g_strdup_printf ("Call %s (%s)",
 458               folks_phone_field_details_get_normalised (details),
 459               type);
 460         }
 461       else
 462         {
 463           tmp = g_strdup_printf ("Call %s",
 464               folks_phone_field_details_get_normalised (details));
 465         }
 466
 467       item = gtk_image_menu_item_new_with_mnemonic (tmp);
 468       g_free (tmp);
 469
 470       g_signal_connect_data (item, "activate",
 471           G_CALLBACK (call_phone_number_cb), g_object_ref (details),
 472           (GClosureNotify) g_object_unref, 0);
 473
 474       gtk_widget_set_sensitive (item, sensitive);
 475
 476       image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CALL,
 477           GTK_ICON_SIZE_MENU);
 478       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 479       gtk_widget_show (image);
 480
 481       gtk_menu_shell_append (GTK_MENU_SHELL (self), item);
 482       gtk_widget_show (item);
 483     }
 484
 485   g_object_unref (iter);
 486 }
 487
 488 /* return a list of TpContact supporting the blocking iface */
 489 static GList *
 490 get_contacts_supporting_blocking (FolksIndividual *individual)
 491 {
 492   GeeSet *personas;
 493   GeeIterator *iter;
 494   GList *result = NULL;
 495
 496   personas = folks_individual_get_personas (individual);
 497
 498   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 499   while (gee_iterator_next (iter))
 500     {
 501       TpfPersona *persona = gee_iterator_get (iter);
 502       TpContact *contact;
 503       TpConnection *conn;
 504
 505       if (!TPF_IS_PERSONA (persona))
 506         continue;
 507
 508       contact = tpf_persona_get_contact (persona);
 509       if (contact == NULL)
 510         continue;
 511
 512       conn = tp_contact_get_connection (contact);
 513
 514       if (tp_proxy_has_interface_by_id (conn,
 515         TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
 516         result = g_list_prepend (result, contact);
 517     }
 518
 519   g_clear_object (&iter);
 520
 521   return result;
 522 }
 523
 524 typedef struct
 525 {
 526   gboolean blocked;
 527   GtkWidget *parent;
 528 } GotAvatarCtx;
 529
 530 static GotAvatarCtx *
 531 got_avatar_ctx_new (gboolean blocked,
 532     GtkWidget *parent)
 533 {
 534   GotAvatarCtx *ctx = g_slice_new0 (GotAvatarCtx);
 535
 536   ctx->blocked = blocked;
 537   ctx->parent = parent != NULL ? g_object_ref (parent) : NULL;
 538   return ctx;
 539 }
 540
 541 static void
 542 got_avatar_ctx_free (GotAvatarCtx *ctx)
 543 {
 544   g_clear_object (&ctx->parent);
 545   g_slice_free (GotAvatarCtx, ctx);
 546 }
 547
 548 static void
 549 got_avatar (GObject *source_object,
 550     GAsyncResult *result,
 551     gpointer user_data)
 552 {
 553   FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object);
 554   GotAvatarCtx *ctx = user_data;
 555   GdkPixbuf *avatar;
 556   GError *error = NULL;
 557   gboolean abusive = FALSE;
 558   EmpathyIndividualManager *manager;
 559
 560   avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual,
 561       result, &error);
 562
 563   if (error != NULL)
 564     {
 565       DEBUG ("Could not get avatar: %s", error->message);
 566       g_error_free (error);
 567     }
 568
 569   if (ctx->blocked) {
 570     /* confirm the user really wishes to block the contact */
 571     if (!empathy_block_individual_dialog_show (GTK_WINDOW (ctx->parent),
 572           individual, avatar, &abusive))
 573       goto out;
 574   }
 575
 576   manager = empathy_individual_manager_dup_singleton ();
 577
 578   empathy_individual_manager_set_blocked (manager, individual,
 579       ctx->blocked, abusive);
 580
 581   g_object_unref (manager);
 582
 583 out:
 584   g_clear_object (&avatar);
 585   got_avatar_ctx_free (ctx);
 586 }
 587
 588 static void
 589 empathy_individual_block_menu_item_toggled (GtkCheckMenuItem *item,
 590     FolksIndividual *individual)
 591 {
 592   GotAvatarCtx *ctx;
 593   gboolean blocked;
 594   GtkWidget *parent;
 595
 596   /* @item may be destroyed while the async call is running to get the things
 597    * we need from it right now. */
 598   blocked = gtk_check_menu_item_get_active (item);
 599
 600   parent = g_object_get_data (
 601     G_OBJECT (gtk_widget_get_parent (GTK_WIDGET (item))),
 602     "window");
 603
 604   ctx = got_avatar_ctx_new (blocked, parent);
 605
 606   empathy_pixbuf_avatar_from_individual_scaled_async (individual,
 607       48, 48, NULL, got_avatar, ctx);
 608 }
 609
 610 static void
 611 update_block_menu_item (GtkWidget *item,
 612     FolksIndividual *individual)
 613 {
 614   GList *contacts, *l;
 615   gboolean is_blocked = TRUE;
 616
 617   contacts = get_contacts_supporting_blocking (individual);
 618
 619   if (contacts == NULL)
 620     is_blocked = FALSE;
 621
 622   /* Check the menu item if all his personas are blocked */
 623   for (l = contacts; l != NULL; l = g_list_next (l))
 624     {
 625       TpContact *contact = l->data;
 626
 627       if (!tp_contact_is_blocked (contact))
 628         {
 629           is_blocked = FALSE;
 630           break;
 631         }
 632     }
 633
 634   g_signal_handlers_block_by_func (item,
 635       empathy_individual_block_menu_item_toggled, individual);
 636
 637   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), is_blocked);
 638
 639   g_signal_handlers_unblock_by_func (item,
 640       empathy_individual_block_menu_item_toggled, individual);
 641
 642   g_list_free (contacts);
 643 }
 644
 645 static void
 646 contact_blocked_changed_cb (TpContact *contact,
 647     GParamSpec *spec,
 648     GtkWidget *item)
 649 {
 650   FolksIndividual *individual;
 651
 652   individual = g_object_get_data (G_OBJECT (item), "individual");
 653
 654   update_block_menu_item (item, individual);
 655 }
 656
 657 static GtkWidget *
 658 empathy_individiual_block_menu_item_new (FolksIndividual *individual)
 659 {
 660   GtkWidget *item;
 661   GList *contacts, *l;
 662
 663   contacts = get_contacts_supporting_blocking (individual);
 664
 665   /* Can't block, no persona supports blocking */
 666   if (contacts == NULL)
 667     return NULL;
 668
 669   item = gtk_check_menu_item_new_with_mnemonic (_("_Block Contact"));
 670
 671   g_object_set_data_full (G_OBJECT (item), "individual",
 672       g_object_ref (individual), g_object_unref);
 673
 674   for (l = contacts; l != NULL; l = g_list_next (l))
 675     {
 676       TpContact *contact = l->data;
 677
 678       tp_g_signal_connect_object (contact, "notify::is-blocked",
 679           G_CALLBACK (contact_blocked_changed_cb), item, 0);
 680     }
 681
 682   g_signal_connect (item, "toggled",
 683       G_CALLBACK (empathy_individual_block_menu_item_toggled), individual);
 684
 685   update_block_menu_item (item, individual);
 686
 687   g_list_free (contacts);
 688
 689   return item;
 690 }
 691
 692 enum
 693 {
 694   REMOVE_DIALOG_RESPONSE_CANCEL = 0,
 695   REMOVE_DIALOG_RESPONSE_DELETE,
 696   REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK,
 697   REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP
 698 };
 699
 700 static int
 701 remove_dialog_show (const gchar *message,
 702     const gchar *secondary_text,
 703     gboolean show_remove_from_group,
 704     gboolean block_button,
 705     GdkPixbuf *avatar,
 706     const gchar *active_group)
 707 {
 708   GtkWidget *dialog;
 709   gboolean res;
 710
 711   dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
 712       GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", message);
 713
 714   if (avatar != NULL)
 715     {
 716       GtkWidget *image = gtk_image_new_from_pixbuf (avatar);
 717       gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
 718       gtk_widget_show (image);
 719     }
 720
 721   if (show_remove_from_group)
 722     {
 723       GtkWidget *button;
 724       gchar *button_text = g_strdup_printf (_("Remove from _Group \'%s\'"),
 725           active_group);
 726
 727       /* gtk_dialog_add_button() doesn't allow us to pass a string with a
 728        * mnemonic so we have to create the button manually. */
 729       button = gtk_button_new_with_mnemonic (button_text);
 730       g_free (button_text);
 731
 732       gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
 733           REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP);
 734
 735       gtk_widget_show (button);
 736     }
 737
 738   if (block_button)
 739     {
 740       GtkWidget *button;
 741
 742       /* gtk_dialog_add_button() doesn't allow us to pass a string with a
 743        * mnemonic so we have to create the button manually. */
 744       button = gtk_button_new_with_mnemonic (
 745           _("Delete and _Block"));
 746
 747       gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
 748           REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK);
 749
 750       gtk_widget_show (button);
 751     }
 752
 753   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 754       GTK_STOCK_CANCEL, REMOVE_DIALOG_RESPONSE_CANCEL,
 755       GTK_STOCK_DELETE, REMOVE_DIALOG_RESPONSE_DELETE, NULL);
 756   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 757       "%s", secondary_text);
 758
 759   gtk_widget_show (dialog);
 760
 761   res = gtk_dialog_run (GTK_DIALOG (dialog));
 762   gtk_widget_destroy (dialog);
 763
 764   return res;
 765 }
 766
 767 static void
 768 individual_removed_from_group_cb (GObject *source_object,
 769     GAsyncResult *res,
 770     gpointer user_data)
 771 {
 772   GError *error = NULL;
 773   FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object);
 774
 775   folks_group_details_change_group_finish (
 776       FOLKS_GROUP_DETAILS (individual), res, &error);
 777   if (error != NULL)
 778     {
 779       DEBUG ("Individual could not be removed from group: %s",
 780           error->message);
 781       g_error_free (error);
 782     }
 783 }
 784
 785 static void
 786 remove_got_avatar (GObject *source_object,
 787     GAsyncResult *result,
 788     gpointer user_data)
 789 {
 790   FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object);
 791   EmpathyIndividualMenu *self = EMPATHY_INDIVIDUAL_MENU (user_data);
 792   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 793   GdkPixbuf *avatar;
 794   EmpathyIndividualManager *manager;
 795   gchar *text;
 796   GeeSet *personas;
 797   guint persona_count = 0;
 798   gboolean can_block;
 799   GError *error = NULL;
 800   gint res;
 801   gboolean show_remove_from_group;
 802   GeeSet *groups;
 803
 804   avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual,
 805       result, &error);
 806
 807   if (error != NULL)
 808     {
 809       DEBUG ("Could not get avatar: %s", error->message);
 810       g_error_free (error);
 811     }
 812
 813   /* We couldn't retrieve the avatar, but that isn't a fatal error,
 814    * so we still display the remove dialog. */
 815
 816   groups = folks_group_details_get_groups (FOLKS_GROUP_DETAILS (individual));
 817   show_remove_from_group =
 818       gee_collection_get_size (GEE_COLLECTION (groups)) > 1;
 819
 820   personas = folks_individual_get_personas (individual);
 821
 822   persona_count = gee_collection_get_size (GEE_COLLECTION (personas));
 823
 824   /* If we have more than one TpfPersona, display a different message
 825    * ensuring the user knows that *all* of the meta-contacts' personas will
 826    * be removed. */
 827
 828   if (persona_count < 2)
 829     {
 830       /* Not a meta-contact */
 831       text =
 832           g_strdup_printf (
 833               _("Do you really want to remove the contact '%s'?"),
 834               folks_alias_details_get_alias (
 835                   FOLKS_ALIAS_DETAILS (individual)));
 836     }
 837   else
 838     {
 839       /* Meta-contact */
 840       text =
 841           g_strdup_printf (
 842               _("Do you really want to remove the linked contact '%s'? "
 843                 "Note that this will remove all the contacts which make up "
 844                 "this linked contact."),
 845               folks_alias_details_get_alias (
 846                   FOLKS_ALIAS_DETAILS (individual)));
 847     }
 848
 849
 850   manager = empathy_individual_manager_dup_singleton ();
 851   can_block = empathy_individual_manager_supports_blocking (manager,
 852       individual);
 853   res = remove_dialog_show (_("Removing contact"), text,
 854       show_remove_from_group, can_block, avatar, priv->active_group);
 855
 856   if (res == REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP)
 857     {
 858       folks_group_details_change_group (FOLKS_GROUP_DETAILS (individual),
 859           priv->active_group, false, individual_removed_from_group_cb, NULL);
 860       goto finally;
 861     }
 862
 863   if (res == REMOVE_DIALOG_RESPONSE_DELETE ||
 864       res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK)
 865     {
 866       gboolean abusive;
 867
 868       if (res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK)
 869         {
 870           if (!empathy_block_individual_dialog_show (NULL, individual,
 871                 avatar, &abusive))
 872             goto finally;
 873
 874           empathy_individual_manager_set_blocked (manager, individual,
 875               TRUE, abusive);
 876         }
 877
 878       empathy_individual_manager_remove (manager, individual, "");
 879     }
 880
 881  finally:
 882   g_free (text);
 883   g_object_unref (manager);
 884   g_object_unref (self);
 885 }
 886
 887 static void
 888 remove_activate_cb (GtkMenuItem *menuitem,
 889     EmpathyIndividualMenu *self)
 890 {
 891   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 892
 893   empathy_pixbuf_avatar_from_individual_scaled_async (priv->individual,
 894       48, 48, NULL, remove_got_avatar, g_object_ref (self));
 895 }
 896
 897 static GtkWidget *
 898 empathy_individiual_remove_menu_item_new (EmpathyIndividualMenu *self)
 899 {
 900   GeeSet *personas;
 901   GeeIterator *iter;
 902   gboolean can_remove = FALSE;
 903   GtkWidget *item, *image;
 904   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 905
 906   /* If any of the Individual's personas can be removed, add an option to
 907    * remove. This will act as a best-effort option. If any Personas cannot be
 908    * removed from the server, then this option will just be inactive upon
 909    * subsequent menu openings */
 910   personas = folks_individual_get_personas (priv->individual);
 911   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 912   while (!can_remove && gee_iterator_next (iter))
 913     {
 914       FolksPersona *persona = gee_iterator_get (iter);
 915       FolksPersonaStore *store = folks_persona_get_store (persona);
 916       FolksMaybeBool maybe_can_remove =
 917           folks_persona_store_get_can_remove_personas (store);
 918
 919       if (maybe_can_remove == FOLKS_MAYBE_BOOL_TRUE)
 920         can_remove = TRUE;
 921
 922       g_clear_object (&persona);
 923     }
 924   g_clear_object (&iter);
 925
 926   if (!can_remove)
 927     return NULL;
 928
 929   item = gtk_image_menu_item_new_with_mnemonic (_("_Remove"));
 930   image = gtk_image_new_from_icon_name (GTK_STOCK_REMOVE,
 931       GTK_ICON_SIZE_MENU);
 932   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 933
 934   g_signal_connect (item, "activate",
 935       G_CALLBACK (remove_activate_cb), self);
 936
 937   return item;
 938 }
 939
 940 static void
 941 constructed (GObject *object)
 942 {
 943   EmpathyIndividualMenu *self = EMPATHY_INDIVIDUAL_MENU (object);
 944   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
 945   GtkMenuShell *shell;
 946   GtkWidget *item;
 947   FolksIndividual *individual;
 948   EmpathyIndividualFeatureFlags features;
 949
 950   /* Build the menu */
 951   shell = GTK_MENU_SHELL (object);
 952   individual = priv->individual;
 953   features = priv->features;
 954
 955   /* Add contact */
 956   if (features & EMPATHY_INDIVIDUAL_FEATURE_ADD_CONTACT)
 957     {
 958       item = empathy_individual_add_menu_item_new (self, individual);
 959       if (item != NULL)
 960         {
 961           gtk_menu_shell_append (GTK_MENU_SHELL (shell), item);
 962           gtk_widget_show (item);
 963         }
 964     }
 965
 966   /* Chat */
 967   if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
 968     {
 969       item = empathy_individual_chat_menu_item_new (individual);
 970       if (item != NULL)
 971         {
 972           gtk_menu_shell_append (shell, item);
 973           gtk_widget_show (item);
 974         }
 975     }
 976
 977   /* SMS */
 978   if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS)
 979     {
 980       item = empathy_individual_sms_menu_item_new (individual);
 981       if (item != NULL)
 982         {
 983           gtk_menu_shell_append (shell, item);
 984           gtk_widget_show (item);
 985         }
 986     }
 987
 988   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
 989     {
 990       /* Audio Call */
 991       item = empathy_individual_audio_call_menu_item_new (individual);
 992       gtk_menu_shell_append (shell, item);
 993       gtk_widget_show (item);
 994
 995       /* Video Call */
 996       item = empathy_individual_video_call_menu_item_new (individual);
 997       gtk_menu_shell_append (shell, item);
 998       gtk_widget_show (item);
 999     }
1000
1001   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL_PHONE)
1002     add_phone_numbers (self);
1003
1004   /* Invite */
1005   item = empathy_individual_invite_menu_item_new (individual, NULL);
1006   gtk_menu_shell_append (shell, item);
1007   gtk_widget_show (item);
1008
1009   /* File transfer */
1010   if (features & EMPATHY_INDIVIDUAL_FEATURE_FILE_TRANSFER)
1011     {
1012       item = empathy_individual_file_transfer_menu_item_new (individual);
1013       gtk_menu_shell_append (shell, item);
1014       gtk_widget_show (item);
1015     }
1016
1017   /* Share my desktop */
1018   /* FIXME we should add the "Share my desktop" menu item if Vino is
1019   a registered handler in MC5 */
1020   item = empathy_individual_share_my_desktop_menu_item_new (individual);
1021   gtk_menu_shell_append (shell, item);
1022   gtk_widget_show (item);
1023
1024   /* Menu items to target specific contacts */
1025   individual_menu_add_personas (GTK_MENU_SHELL (object), individual, features);
1026
1027   /* Separator */
1028   if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT |
1029       EMPATHY_INDIVIDUAL_FEATURE_INFO |
1030       EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE))
1031     {
1032       item = gtk_separator_menu_item_new ();
1033       gtk_menu_shell_append (shell, item);
1034       gtk_widget_show (item);
1035     }
1036
1037   /* Edit */
1038   if (features & EMPATHY_INDIVIDUAL_FEATURE_EDIT)
1039     {
1040       item = empathy_individual_edit_menu_item_new (individual);
1041       gtk_menu_shell_append (shell, item);
1042       gtk_widget_show (item);
1043     }
1044
1045   /* Log */
1046   if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
1047     {
1048       item = empathy_individual_log_menu_item_new (individual);
1049       gtk_menu_shell_append (shell, item);
1050       gtk_widget_show (item);
1051     }
1052
1053   /* Info */
1054   if (features & EMPATHY_INDIVIDUAL_FEATURE_INFO)
1055     {
1056       item = empathy_individual_info_menu_item_new (individual);
1057       gtk_menu_shell_append (shell, item);
1058       gtk_widget_show (item);
1059     }
1060
1061   /* Favorite checkbox */
1062   if (features & EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE)
1063     {
1064       item = empathy_individual_favourite_menu_item_new (individual);
1065       gtk_menu_shell_append (shell, item);
1066       gtk_widget_show (item);
1067     }
1068
1069   /* Separator & Block */
1070   if (features & EMPATHY_INDIVIDUAL_FEATURE_BLOCK &&
1071       (item = empathy_individiual_block_menu_item_new (individual)) != NULL) {
1072     GtkWidget *sep;
1073
1074     sep = gtk_separator_menu_item_new ();
1075     gtk_menu_shell_append (shell, sep);
1076     gtk_widget_show (sep);
1077
1078     gtk_menu_shell_append (shell, item);
1079     gtk_widget_show (item);
1080   }
1081
1082   /* Separator & Remove */
1083   if (features & EMPATHY_INDIVIDUAL_FEATURE_REMOVE &&
1084       (item = empathy_individiual_remove_menu_item_new (self)) != NULL) {
1085     GtkWidget *sep;
1086
1087     sep = gtk_separator_menu_item_new ();
1088     gtk_menu_shell_append (shell, sep);
1089     gtk_widget_show (sep);
1090
1091     gtk_menu_shell_append (shell, item);
1092     gtk_widget_show (item);
1093   }
1094 }
1095
1096 static void
1097 get_property (GObject *object,
1098     guint param_id,
1099     GValue *value,
1100     GParamSpec *pspec)
1101 {
1102   EmpathyIndividualMenuPriv *priv;
1103
1104   priv = GET_PRIV (object);
1105
1106   switch (param_id)
1107     {
1108       case PROP_ACTIVE_GROUP:
1109         g_value_set_string (value, priv->active_group);
1110         break;
1111       case PROP_INDIVIDUAL:
1112         g_value_set_object (value, priv->individual);
1113         break;
1114       case PROP_FEATURES:
1115         g_value_set_flags (value, priv->features);
1116         break;
1117       case PROP_STORE:
1118         g_value_set_object (value, priv->store);
1119         break;
1120       default:
1121         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1122         break;
1123     }
1124 }
1125
1126 static void
1127 set_property (GObject *object,
1128     guint param_id,
1129     const GValue *value,
1130     GParamSpec *pspec)
1131 {
1132   EmpathyIndividualMenuPriv *priv;
1133
1134   priv = GET_PRIV (object);
1135
1136   switch (param_id)
1137     {
1138       case PROP_ACTIVE_GROUP:
1139         g_assert (priv->active_group == NULL); /* construct only */
1140         priv->active_group = g_value_dup_string (value);
1141         break;
1142       case PROP_INDIVIDUAL:
1143         priv->individual = g_value_dup_object (value);
1144         break;
1145       case PROP_FEATURES:
1146         priv->features = g_value_get_flags (value);
1147         break;
1148       case PROP_STORE:
1149         priv->store = g_value_dup_object (value); /* read only */
1150         break;
1151       default:
1152         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1153         break;
1154     }
1155 }
1156
1157 static void
1158 dispose (GObject *object)
1159 {
1160   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
1161
1162   tp_clear_object (&priv->individual);
1163   tp_clear_object (&priv->store);
1164
1165   G_OBJECT_CLASS (empathy_individual_menu_parent_class)->dispose (object);
1166 }
1167
1168 static void
1169 finalize (GObject *object)
1170 {
1171   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
1172
1173   g_free (priv->active_group);
1174
1175   G_OBJECT_CLASS (empathy_individual_menu_parent_class)->finalize (object);
1176 }
1177
1178 static void
1179 empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass)
1180 {
1181   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1182
1183   object_class->constructed = constructed;
1184   object_class->get_property = get_property;
1185   object_class->set_property = set_property;
1186   object_class->dispose = dispose;
1187   object_class->finalize = finalize;
1188
1189   /**
1190    * gchar *:active-group:
1191    *
1192    * The group the selected roster-contact widget belongs, or NULL.
1193    */
1194   g_object_class_install_property (object_class, PROP_ACTIVE_GROUP,
1195       g_param_spec_string ("active-group",
1196           "Active group",
1197           "The group the selected roster-contact widget belongs, or NULL",
1198           NULL,
1199           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1200
1201   /**
1202    * EmpathyIndividualMenu:individual:
1203    *
1204    * The #FolksIndividual the menu is for.
1205    */
1206   g_object_class_install_property (object_class, PROP_INDIVIDUAL,
1207       g_param_spec_object ("individual",
1208           "Individual",
1209           "The #FolksIndividual the menu is for.",
1210           FOLKS_TYPE_INDIVIDUAL,
1211           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1212
1213   /**
1214    * EmpathyIndividualMenu:features:
1215    *
1216    * A set of feature flags controlling which entries are shown.
1217    */
1218   g_object_class_install_property (object_class, PROP_FEATURES,
1219       g_param_spec_flags ("features",
1220           "Features",
1221           "A set of feature flags controlling which entries are shown.",
1222           EMPATHY_TYPE_INDIVIDUAL_FEATURE_FLAGS,
1223           EMPATHY_INDIVIDUAL_FEATURE_NONE,
1224           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1225
1226   g_object_class_install_property (object_class, PROP_STORE,
1227       g_param_spec_object ("store",
1228           "Store",
1229           "The EmpathyIndividualStore to use to get contact owner",
1230           EMPATHY_TYPE_INDIVIDUAL_STORE,
1231           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1232
1233   signals[MENU_ITEM_ACTIVATED] =
1234       g_signal_new ("menu-item-activated",
1235           G_TYPE_FROM_CLASS (klass),
1236           G_SIGNAL_RUN_LAST,
1237           0,
1238           NULL, NULL,
1239           g_cclosure_marshal_generic,
1240           G_TYPE_NONE,
1241           0);
1242
1243   g_type_class_add_private (object_class, sizeof (EmpathyIndividualMenuPriv));
1244 }
1245
1246 GtkWidget *
1247 empathy_individual_menu_new (FolksIndividual *individual,
1248     const gchar *active_group,
1249     EmpathyIndividualFeatureFlags features,
1250     EmpathyIndividualStore *store)
1251 {
1252   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1253   g_return_val_if_fail (store == NULL ||
1254       EMPATHY_IS_INDIVIDUAL_STORE (store), NULL);
1255   g_return_val_if_fail (features != EMPATHY_INDIVIDUAL_FEATURE_NONE, NULL);
1256
1257   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MENU,
1258       "active-group", active_group,
1259       "individual", individual,
1260       "features", features,
1261       "store", store,
1262       NULL);
1263 }
1264
1265 /* Like menu_item_set_first_contact(), but always operates upon the given
1266  * contact. If the contact is non-NULL, it is assumed that the menu entry should
1267  * be sensitive. */
1268 static gboolean
1269 menu_item_set_contact (GtkWidget *item,
1270     EmpathyContact *contact,
1271     GCallback activate_callback,
1272     EmpathyActionType action_type)
1273 {
1274   gboolean can_do_action = FALSE;
1275
1276   if (contact != NULL)
1277     can_do_action = empathy_contact_can_do_action (contact, action_type);
1278   gtk_widget_set_sensitive (item, can_do_action);
1279
1280   if (can_do_action == TRUE)
1281     {
1282       /* We want to make sure that the EmpathyContact stays alive while the
1283        * signal is connected. */
1284       g_signal_connect_data (item, "activate", G_CALLBACK (activate_callback),
1285           g_object_ref (contact), (GClosureNotify) g_object_unref, 0);
1286     }
1287
1288   return can_do_action;
1289 }
1290
1291 /**
1292  * Set the given menu @item to call @activate_callback using the TpContact
1293  * (associated with @individual) with the highest availability who is also valid
1294  * whenever @item is activated.
1295  *
1296  * @action_type is the type of action performed by the menu entry; this is used
1297  * so that only contacts which can perform that action (e.g. are capable of
1298  * receiving video calls) are selected, as appropriate.
1299  */
1300 static GtkWidget *
1301 menu_item_set_first_contact (GtkWidget *item,
1302     FolksIndividual *individual,
1303     GCallback activate_callback,
1304     EmpathyActionType action_type)
1305 {
1306   EmpathyContact *best_contact;
1307
1308   best_contact = empathy_contact_dup_best_for_action (individual, action_type);
1309   menu_item_set_contact (item, best_contact, G_CALLBACK (activate_callback),
1310       action_type);
1311   tp_clear_object (&best_contact);
1312
1313   return item;
1314 }
1315
1316 static void
1317 empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
1318   EmpathyContact *contact)
1319 {
1320   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1321
1322   empathy_chat_with_contact (contact, empathy_get_current_action_time ());
1323 }
1324
1325 static GtkWidget *
1326 empathy_individual_chat_menu_item_new (FolksIndividual *individual)
1327 {
1328   GtkWidget *item;
1329   GtkWidget *image;
1330
1331   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) &&
1332       empathy_folks_individual_contains_contact (individual), NULL);
1333
1334   item = gtk_image_menu_item_new_with_mnemonic (_("_Chat"));
1335   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE,
1336       GTK_ICON_SIZE_MENU);
1337   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1338   gtk_widget_show (image);
1339
1340   menu_item_set_first_contact (item, individual,
1341       G_CALLBACK (empathy_individual_chat_menu_item_activated),
1342       EMPATHY_ACTION_CHAT);
1343
1344   return item;
1345 }
1346
1347 static void
1348 empathy_individual_sms_menu_item_activated (GtkMenuItem *item,
1349   EmpathyContact *contact)
1350 {
1351   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1352
1353   empathy_sms_contact_id (
1354       empathy_contact_get_account (contact),
1355       empathy_contact_get_id (contact),
1356       empathy_get_current_action_time (),
1357       NULL, NULL);
1358 }
1359
1360 static GtkWidget *
1361 empathy_individual_sms_menu_item_new (FolksIndividual *individual)
1362 {
1363   GtkWidget *item;
1364   GtkWidget *image;
1365
1366   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) &&
1367       empathy_folks_individual_contains_contact (individual), NULL);
1368
1369   item = gtk_image_menu_item_new_with_mnemonic (_("_SMS"));
1370   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS,
1371       GTK_ICON_SIZE_MENU);
1372   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1373   gtk_widget_show (image);
1374
1375   menu_item_set_first_contact (item, individual,
1376       G_CALLBACK (empathy_individual_sms_menu_item_activated),
1377       EMPATHY_ACTION_SMS);
1378
1379   return item;
1380 }
1381
1382 static void
1383 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
1384   EmpathyContact *contact)
1385 {
1386   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1387
1388   empathy_call_new_with_streams (empathy_contact_get_id (contact),
1389       empathy_contact_get_account (contact),
1390       TRUE, FALSE,
1391       empathy_get_current_action_time ());
1392 }
1393
1394 GtkWidget *
1395 empathy_individual_audio_call_menu_item_new (FolksIndividual *individual)
1396 {
1397   GtkWidget *item;
1398   GtkWidget *image;
1399
1400   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1401
1402   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
1403   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
1404   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1405   gtk_widget_show (image);
1406
1407   menu_item_set_first_contact (item, individual,
1408       G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
1409       EMPATHY_ACTION_AUDIO_CALL);
1410
1411   return item;
1412 }
1413
1414 static void
1415 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
1416   EmpathyContact *contact)
1417 {
1418   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1419
1420   empathy_call_new_with_streams (empathy_contact_get_id (contact),
1421       empathy_contact_get_account (contact),
1422       TRUE, TRUE,
1423       empathy_get_current_action_time ());
1424 }
1425
1426 GtkWidget *
1427 empathy_individual_video_call_menu_item_new (FolksIndividual *individual)
1428 {
1429   GtkWidget *item;
1430   GtkWidget *image;
1431   TpawCameraMonitor *monitor;
1432
1433   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1434
1435   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
1436   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
1437       GTK_ICON_SIZE_MENU);
1438   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1439   gtk_widget_show (image);
1440
1441   menu_item_set_first_contact (item, individual,
1442       G_CALLBACK (empathy_individual_video_call_menu_item_activated),
1443       EMPATHY_ACTION_VIDEO_CALL);
1444
1445   /* Only follow available cameras if the contact can do Video calls */
1446   if (gtk_widget_get_sensitive (item))
1447     {
1448       monitor = tpaw_camera_monitor_dup_singleton ();
1449       g_object_set_data_full (G_OBJECT (item),
1450           "monitor", monitor, g_object_unref);
1451       g_object_bind_property (monitor, "available", item, "sensitive",
1452           G_BINDING_SYNC_CREATE);
1453     }
1454
1455   return item;
1456 }
1457
1458 static void
1459 empathy_individual_log_menu_item_activated (GtkMenuItem *item,
1460   EmpathyContact *contact)
1461 {
1462   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1463
1464   empathy_log_window_show (empathy_contact_get_account (contact),
1465       empathy_contact_get_id (contact), FALSE, NULL);
1466 }
1467
1468 static GtkWidget *
1469 empathy_individual_log_menu_item_new (FolksIndividual *individual)
1470 {
1471   GtkWidget *item;
1472   GtkWidget *image;
1473
1474   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1475
1476   item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations"));
1477   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU);
1478   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1479   gtk_widget_show (image);
1480
1481   menu_item_set_first_contact (item, individual,
1482       G_CALLBACK (empathy_individual_log_menu_item_activated),
1483       EMPATHY_ACTION_VIEW_LOGS);
1484
1485   return item;
1486 }
1487
1488 static void
1489 empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
1490     EmpathyContact *contact)
1491 {
1492   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1493
1494   empathy_send_file_with_file_chooser (contact);
1495 }
1496
1497 static GtkWidget *
1498 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual)
1499 {
1500   GtkWidget *item;
1501   GtkWidget *image;
1502
1503   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1504
1505   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
1506   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
1507       GTK_ICON_SIZE_MENU);
1508   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1509   gtk_widget_show (image);
1510
1511   menu_item_set_first_contact (item, individual,
1512       G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
1513       EMPATHY_ACTION_SEND_FILE);
1514
1515   return item;
1516 }
1517
1518 static void
1519 empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item,
1520     EmpathyContact *contact)
1521 {
1522   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1523
1524   empathy_share_my_desktop_share_with_contact (contact);
1525 }
1526
1527 static GtkWidget *
1528 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual)
1529 {
1530   GtkWidget *item;
1531   GtkWidget *image;
1532
1533   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1534
1535   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
1536   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
1537   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1538   gtk_widget_show (image);
1539
1540   menu_item_set_first_contact (item, individual,
1541       G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1542       EMPATHY_ACTION_SHARE_MY_DESKTOP);
1543
1544   return item;
1545 }
1546
1547 static void
1548 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
1549   FolksIndividual *individual)
1550 {
1551   folks_favourite_details_set_is_favourite (
1552       FOLKS_FAVOURITE_DETAILS (individual),
1553       gtk_check_menu_item_get_active (item));
1554 }
1555
1556 static GtkWidget *
1557 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
1558 {
1559   GtkWidget *item;
1560
1561   item = gtk_check_menu_item_new_with_label (_("Favorite"));
1562
1563   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
1564       folks_favourite_details_get_is_favourite (
1565           FOLKS_FAVOURITE_DETAILS (individual)));
1566
1567   g_signal_connect (item, "toggled",
1568       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
1569
1570   return item;
1571 }
1572
1573 static void
1574 individual_info_menu_item_activate_cb (GtkMenuItem *item,
1575     FolksIndividual *individual)
1576 {
1577   empathy_display_individual_info (individual);
1578 }
1579
1580 static GtkWidget *
1581 empathy_individual_info_menu_item_new (FolksIndividual *individual)
1582 {
1583   GtkWidget *item;
1584   GtkWidget *image;
1585
1586   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1587   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
1588       NULL);
1589
1590   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
1591   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
1592                 GTK_ICON_SIZE_MENU);
1593   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1594   gtk_widget_show (image);
1595
1596   g_signal_connect (item, "activate",
1597           G_CALLBACK (individual_info_menu_item_activate_cb),
1598           individual);
1599
1600   return item;
1601 }
1602
1603 static void
1604 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
1605 {
1606   empathy_individual_edit_dialog_show (individual, NULL);
1607 }
1608
1609 static GtkWidget *
1610 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
1611 {
1612   EmpathyIndividualManager *manager;
1613   GtkWidget *item;
1614   GtkWidget *image;
1615   gboolean enable = FALSE;
1616   EmpathyContact *contact;
1617
1618   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1619
1620   contact = empathy_contact_dup_from_folks_individual (individual);
1621
1622   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
1623
1624   if (empathy_individual_manager_initialized ())
1625     {
1626       TpConnection *connection;
1627
1628       manager = empathy_individual_manager_dup_singleton ();
1629       connection = empathy_contact_get_connection (contact);
1630
1631       enable = (empathy_connection_can_alias_personas (connection,
1632                                                        individual) &&
1633                 empathy_connection_can_group_personas (connection, individual));
1634
1635       g_object_unref (manager);
1636     }
1637
1638   item = gtk_image_menu_item_new_with_mnemonic (
1639       C_("Edit individual (contextual menu)", "_Edit"));
1640   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1641   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1642   gtk_widget_show (image);
1643
1644   gtk_widget_set_sensitive (item, enable);
1645
1646   g_signal_connect_swapped (item, "activate",
1647       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
1648
1649   g_object_unref (contact);
1650
1651   return item;
1652 }
1653
1654 typedef struct
1655 {
1656   FolksIndividual *individual;
1657   EmpathyContact *contact;
1658   EmpathyChatroom *chatroom;
1659 } RoomSubMenuData;
1660
1661 static RoomSubMenuData *
1662 room_sub_menu_data_new (FolksIndividual *individual,
1663     EmpathyContact *contact,
1664     EmpathyChatroom *chatroom)
1665 {
1666   RoomSubMenuData *data;
1667
1668   data = g_slice_new0 (RoomSubMenuData);
1669   if (individual != NULL)
1670     data->individual = g_object_ref (individual);
1671   if (contact != NULL)
1672     data->contact = g_object_ref (contact);
1673   data->chatroom = g_object_ref (chatroom);
1674
1675   return data;
1676 }
1677
1678 static void
1679 room_sub_menu_data_free (RoomSubMenuData *data)
1680 {
1681   tp_clear_object (&data->individual);
1682   tp_clear_object (&data->contact);
1683   g_object_unref (data->chatroom);
1684   g_slice_free (RoomSubMenuData, data);
1685 }
1686
1687 static void
1688 room_sub_menu_activate_cb (GtkWidget *item,
1689          RoomSubMenuData *data)
1690 {
1691   EmpathyTpChat *chat;
1692   EmpathyChatroomManager *mgr;
1693   EmpathyContact *contact = NULL;
1694
1695   chat = empathy_chatroom_get_tp_chat (data->chatroom);
1696   if (chat == NULL)
1697     {
1698       /* channel was invalidated. Ignoring */
1699       return;
1700     }
1701
1702   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1703
1704   if (data->contact != NULL)
1705     contact = g_object_ref (data->contact);
1706   else
1707     {
1708       GeeSet *personas;
1709       GeeIterator *iter;
1710
1711       /* find the first of this Individual's contacts who can join this room */
1712       personas = folks_individual_get_personas (data->individual);
1713
1714       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1715       while (gee_iterator_next (iter) && (contact == NULL))
1716         {
1717           TpfPersona *persona = gee_iterator_get (iter);
1718           TpContact *tp_contact;
1719           GList *rooms;
1720
1721           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1722             {
1723               tp_contact = tpf_persona_get_contact (persona);
1724               if (tp_contact != NULL)
1725                 {
1726                   contact = empathy_contact_dup_from_tp_contact (tp_contact);
1727
1728                   rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1729                       empathy_contact_get_account (contact));
1730
1731                   if (g_list_find (rooms, data->chatroom) == NULL)
1732                     g_clear_object (&contact);
1733
1734                   /* if contact != NULL here, we've found our match */
1735
1736                   g_list_free (rooms);
1737                 }
1738             }
1739           g_clear_object (&persona);
1740         }
1741       g_clear_object (&iter);
1742     }
1743
1744   g_object_unref (mgr);
1745
1746   if (contact == NULL)
1747     {
1748       /* contact disappeared. Ignoring */
1749       goto out;
1750     }
1751
1752   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1753
1754   /* send invitation */
1755   empathy_tp_chat_add (chat, contact, _("Inviting you to this room"));
1756
1757 out:
1758   g_object_unref (contact);
1759 }
1760
1761 static GtkWidget *
1762 create_room_sub_menu (FolksIndividual *individual,
1763                       EmpathyContact *contact,
1764                       EmpathyChatroom *chatroom)
1765 {
1766   GtkWidget *item;
1767   RoomSubMenuData *data;
1768
1769   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
1770   data = room_sub_menu_data_new (individual, contact, chatroom);
1771   g_signal_connect_data (item, "activate",
1772       G_CALLBACK (room_sub_menu_activate_cb), data,
1773       (GClosureNotify) room_sub_menu_data_free, 0);
1774
1775   return item;
1776 }
1777
1778 static GtkWidget *
1779 empathy_individual_invite_menu_item_new (FolksIndividual *individual,
1780     EmpathyContact *contact)
1781 {
1782   GtkWidget *item;
1783   GtkWidget *image;
1784   GtkWidget *room_item;
1785   EmpathyChatroomManager *mgr;
1786   GList *rooms = NULL;
1787   GList *names = NULL;
1788   GList *l;
1789   GtkWidget *submenu = NULL;
1790   /* map of chat room names to their objects; just a utility to remove
1791    * duplicates and to make construction of the alphabetized list easier */
1792   GHashTable *name_room_map;
1793
1794   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1795       EMPATHY_IS_CONTACT (contact),
1796       NULL);
1797
1798   name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
1799       g_object_unref);
1800
1801   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
1802   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
1803       GTK_ICON_SIZE_MENU);
1804   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1805
1806   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1807
1808   if (contact != NULL)
1809     {
1810       rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1811           empathy_contact_get_account (contact));
1812     }
1813   else
1814     {
1815       GeeSet *personas;
1816       GeeIterator *iter;
1817
1818       /* find the first of this Individual's contacts who can join this room */
1819       personas = folks_individual_get_personas (individual);
1820       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1821       while (gee_iterator_next (iter))
1822         {
1823           TpfPersona *persona = gee_iterator_get (iter);
1824           GList *rooms_cur;
1825           TpContact *tp_contact;
1826           EmpathyContact *contact_cur;
1827
1828           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1829             {
1830               tp_contact = tpf_persona_get_contact (persona);
1831               if (tp_contact != NULL)
1832                 {
1833                   contact_cur = empathy_contact_dup_from_tp_contact (
1834                       tp_contact);
1835
1836                   rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
1837                       empathy_contact_get_account (contact_cur));
1838                   rooms = g_list_concat (rooms, rooms_cur);
1839
1840                   g_object_unref (contact_cur);
1841                 }
1842             }
1843           g_clear_object (&persona);
1844         }
1845       g_clear_object (&iter);
1846     }
1847
1848   /* alphabetize the rooms */
1849   for (l = rooms; l != NULL; l = g_list_next (l))
1850     {
1851       EmpathyChatroom *chatroom = l->data;
1852       gboolean existed;
1853
1854       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
1855         {
1856           const gchar *name;
1857
1858           name = empathy_chatroom_get_name (chatroom);
1859           existed = (g_hash_table_lookup (name_room_map, name) != NULL);
1860           g_hash_table_insert (name_room_map, (gpointer) name,
1861               g_object_ref (chatroom));
1862
1863           /* this will take care of duplicates in rooms */
1864           if (!existed)
1865             {
1866               names = g_list_insert_sorted (names, (gpointer) name,
1867                   (GCompareFunc) g_strcmp0);
1868             }
1869         }
1870     }
1871
1872   for (l = names; l != NULL; l = g_list_next (l))
1873     {
1874       const gchar *name = l->data;
1875       EmpathyChatroom *chatroom;
1876
1877       if (G_UNLIKELY (submenu == NULL))
1878         submenu = gtk_menu_new ();
1879
1880       chatroom = g_hash_table_lookup (name_room_map, name);
1881       room_item = create_room_sub_menu (individual, contact, chatroom);
1882       gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
1883       gtk_widget_show (room_item);
1884     }
1885
1886   if (submenu)
1887     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
1888   else
1889     gtk_widget_set_sensitive (item, FALSE);
1890
1891   gtk_widget_show (image);
1892
1893   g_hash_table_unref (name_room_map);
1894   g_object_unref (mgr);
1895   g_list_free (names);
1896   g_list_free (rooms);
1897
1898   return item;
1899 }
1900
1901 static void
1902 add_menu_item_activated (GtkMenuItem *item,
1903     TpContact *tp_contact)
1904 {
1905   GtkWidget *toplevel;
1906   FolksIndividual *individual;
1907
1908   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (item));
1909   if (!gtk_widget_is_toplevel (toplevel) || !GTK_IS_WINDOW (toplevel))
1910     toplevel = NULL;
1911
1912   individual = empathy_ensure_individual_from_tp_contact (tp_contact);
1913
1914   empathy_new_individual_dialog_show_with_individual (GTK_WINDOW (toplevel),
1915       individual);
1916
1917   g_object_unref (individual);
1918 }
1919
1920 static GtkWidget *
1921 empathy_individual_add_menu_item_new (EmpathyIndividualMenu *self,
1922     FolksIndividual *individual)
1923 {
1924   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
1925   GtkWidget *item, *image;
1926   GeeSet *personas;
1927   GeeIterator *iter;
1928   TpContact *to_add = NULL;
1929
1930   /* find the first of this Individual's personas which are not in our contact
1931    * list. */
1932   personas = folks_individual_get_personas (individual);
1933   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1934   while (gee_iterator_next (iter))
1935     {
1936       TpfPersona *persona = gee_iterator_get (iter);
1937       TpContact *contact;
1938       TpConnection *conn;
1939
1940       if (!TPF_IS_PERSONA (persona))
1941         goto next;
1942
1943       contact = tpf_persona_get_contact (persona);
1944       if (contact == NULL)
1945         goto next;
1946
1947       /* be sure to use a not channel specific contact.
1948        * TODO: Ideally tp-glib should do this for us (fdo #42702)*/
1949       if (EMPATHY_IS_INDIVIDUAL_STORE_CHANNEL (priv->store))
1950         {
1951           TpChannel *channel;
1952           TpChannelGroupFlags flags;
1953
1954           channel = empathy_individual_store_channel_get_channel (
1955               EMPATHY_INDIVIDUAL_STORE_CHANNEL (priv->store));
1956
1957           flags = tp_channel_group_get_flags (channel);
1958           if ((flags & TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES) != 0)
1959             {
1960               /* Channel uses channel specific handles (thanks XMPP...) */
1961               contact = tp_channel_group_get_contact_owner (channel, contact);
1962
1963               /* If we don't know the owner, we can't add the contact */
1964               if (contact == NULL)
1965                 goto next;
1966             }
1967         }
1968
1969       conn = tp_contact_get_connection (contact);
1970       if (conn == NULL)
1971         goto next;
1972
1973       /* No point to try adding a contact if the CM doesn't support it */
1974       if (!tp_connection_get_can_change_contact_list (conn))
1975         goto next;
1976
1977       /* Can't add ourself */
1978       if (tp_connection_get_self_contact (conn) == contact)
1979         goto next;
1980
1981       if (tp_contact_get_subscribe_state (contact) == TP_SUBSCRIPTION_STATE_YES)
1982         goto next;
1983
1984       g_object_unref (persona);
1985       to_add = contact;
1986       break;
1987
1988 next:
1989       g_object_unref (persona);
1990     }
1991
1992   g_object_unref (iter);
1993
1994   if (to_add == NULL)
1995     return NULL;
1996
1997   item = gtk_image_menu_item_new_with_mnemonic (_("_Add Contact…"));
1998   image = gtk_image_new_from_icon_name (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
1999   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
2000
2001   g_signal_connect_data (item, "activate",
2002       G_CALLBACK (add_menu_item_activated),
2003       g_object_ref (to_add), (GClosureNotify) g_object_unref, 0);
2004
2005   return item;
2006 }