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