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
  30 #include <telepathy-glib/telepathy-glib.h>
  31
  32 #include <folks/folks.h>
  33 #include <folks/folks-telepathy.h>
  34
  35 #include <libempathy/empathy-camera-monitor.h>
  36 #include <libempathy/empathy-request-util.h>
  37 #include <libempathy/empathy-individual-manager.h>
  38 #include <libempathy/empathy-chatroom-manager.h>
  39 #include <libempathy/empathy-utils.h>
  40
  41 #include "empathy-account-selector-dialog.h"
  42 #include "empathy-individual-menu.h"
  43 #include "empathy-images.h"
  44 #include "empathy-log-window.h"
  45 #include "empathy-individual-dialogs.h"
  46 #include "empathy-gtk-enum-types.h"
  47 #include "empathy-individual-dialogs.h"
  48 #include "empathy-individual-edit-dialog.h"
  49 #include "empathy-ui-utils.h"
  50 #include "empathy-share-my-desktop.h"
  51 #include "empathy-call-utils.h"
  52 #include "empathy-individual-store-channel.h"
  53 #include "empathy-individual-information-dialog.h"
  54
  55 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  56 #include <libempathy/empathy-debug.h>
  57
  58 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualMenu)
  59
  60 typedef struct {
  61   FolksIndividual *individual; /* owned */
  62   EmpathyIndividualFeatureFlags features;
  63   EmpathyIndividualStore *store; /* may be NULL */
  64 } EmpathyIndividualMenuPriv;
  65
  66 enum {
  67   PROP_INDIVIDUAL = 1,
  68   PROP_FEATURES,
  69   PROP_STORE,
  70 };
  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     FolksIndividual *individual);
 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   gboolean c;
 111
 112   g_return_if_fail (GTK_IS_MENU (menu));
 113   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
 114   g_return_if_fail (empathy_folks_individual_contains_contact (individual));
 115
 116   personas = folks_individual_get_personas (individual);
 117   /* we'll re-use this iterator throughout */
 118   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 119
 120   /* Make sure we've got enough valid entries for these menu items to add
 121    * functionality */
 122   while (gee_iterator_next (iter))
 123     {
 124       FolksPersona *persona = gee_iterator_get (iter);
 125       if (empathy_folks_persona_is_interesting (persona))
 126         persona_count++;
 127
 128       g_clear_object (&persona);
 129     }
 130
 131   /* return early if these entries would add nothing beyond the "quick" items */
 132   if (persona_count <= 1)
 133     goto out;
 134
 135   /* add a separator before the list of personas */
 136   item = gtk_separator_menu_item_new ();
 137   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 138   gtk_widget_show (item);
 139
 140   for (c = gee_iterator_first (iter); c; c = 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 (!empathy_account_has_uri_scheme_tel (account))
 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
 486 /* return a list of TpContact supporting the blocking iface */
 487 static GList *
 488 get_contacts_supporting_blocking (FolksIndividual *individual)
 489 {
 490   GeeSet *personas;
 491   GeeIterator *iter;
 492   GList *result = NULL;
 493
 494   personas = folks_individual_get_personas (individual);
 495
 496   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 497   while (gee_iterator_next (iter))
 498     {
 499       TpfPersona *persona = gee_iterator_get (iter);
 500       TpContact *contact;
 501       TpConnection *conn;
 502
 503       if (!TPF_IS_PERSONA (persona))
 504         continue;
 505
 506       contact = tpf_persona_get_contact (persona);
 507       if (contact == NULL)
 508         continue;
 509
 510       conn = tp_contact_get_connection (contact);
 511
 512       if (tp_proxy_has_interface_by_id (conn,
 513         TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
 514         result = g_list_prepend (result, contact);
 515     }
 516
 517   g_clear_object (&iter);
 518
 519   return result;
 520 }
 521
 522 typedef struct
 523 {
 524   gboolean blocked;
 525   GtkWidget *parent;
 526 } GotAvatarCtx;
 527
 528 static GotAvatarCtx *
 529 got_avatar_ctx_new (gboolean blocked,
 530     GtkWidget *parent)
 531 {
 532   GotAvatarCtx *ctx = g_slice_new0 (GotAvatarCtx);
 533
 534   ctx->blocked = blocked;
 535   ctx->parent = parent != NULL ? g_object_ref (parent) : NULL;
 536   return ctx;
 537 }
 538
 539 static void
 540 got_avatar_ctx_free (GotAvatarCtx *ctx)
 541 {
 542   g_clear_object (&ctx->parent);
 543   g_slice_free (GotAvatarCtx, ctx);
 544 }
 545
 546 static void
 547 got_avatar (GObject *source_object,
 548     GAsyncResult *result,
 549     gpointer user_data)
 550 {
 551   FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object);
 552   GotAvatarCtx *ctx = user_data;
 553   GdkPixbuf *avatar;
 554   GError *error = NULL;
 555   gboolean abusive = FALSE;
 556   EmpathyIndividualManager *manager;
 557
 558   avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual,
 559       result, &error);
 560
 561   if (error != NULL)
 562     {
 563       DEBUG ("Could not get avatar: %s", error->message);
 564       g_error_free (error);
 565     }
 566
 567   if (ctx->blocked) {
 568     /* confirm the user really wishes to block the contact */
 569     if (!empathy_block_individual_dialog_show (GTK_WINDOW (ctx->parent),
 570           individual, avatar, &abusive))
 571       goto out;
 572   }
 573
 574   manager = empathy_individual_manager_dup_singleton ();
 575
 576   empathy_individual_manager_set_blocked (manager, individual,
 577       ctx->blocked, abusive);
 578
 579   g_object_unref (manager);
 580
 581 out:
 582   g_clear_object (&avatar);
 583   got_avatar_ctx_free (ctx);
 584 }
 585
 586 static void
 587 empathy_individual_block_menu_item_toggled (GtkCheckMenuItem *item,
 588     FolksIndividual *individual)
 589 {
 590   GotAvatarCtx *ctx;
 591   gboolean blocked;
 592   GtkWidget *parent;
 593
 594   /* @item may be destroyed while the async call is running to get the things
 595    * we need from it right now. */
 596   blocked = gtk_check_menu_item_get_active (item);
 597
 598   parent = g_object_get_data (
 599     G_OBJECT (gtk_widget_get_parent (GTK_WIDGET (item))),
 600     "window");
 601
 602   ctx = got_avatar_ctx_new (blocked, parent);
 603
 604   empathy_pixbuf_avatar_from_individual_scaled_async (individual,
 605       48, 48, NULL, got_avatar, ctx);
 606 }
 607
 608 static void
 609 update_block_menu_item (GtkWidget *item,
 610     FolksIndividual *individual)
 611 {
 612   GList *contacts, *l;
 613   gboolean is_blocked = TRUE;
 614
 615   contacts = get_contacts_supporting_blocking (individual);
 616
 617   if (contacts == NULL)
 618     is_blocked = FALSE;
 619
 620   /* Check the menu item if all his personas are blocked */
 621   for (l = contacts; l != NULL; l = g_list_next (l))
 622     {
 623       TpContact *contact = l->data;
 624
 625       if (!tp_contact_is_blocked (contact))
 626         {
 627           is_blocked = FALSE;
 628           break;
 629         }
 630     }
 631
 632   g_signal_handlers_block_by_func (item,
 633       empathy_individual_block_menu_item_toggled, individual);
 634
 635   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), is_blocked);
 636
 637   g_signal_handlers_unblock_by_func (item,
 638       empathy_individual_block_menu_item_toggled, individual);
 639
 640   g_list_free (contacts);
 641 }
 642
 643 static void
 644 contact_blocked_changed_cb (TpContact *contact,
 645     GParamSpec *spec,
 646     GtkWidget *item)
 647 {
 648   FolksIndividual *individual;
 649
 650   individual = g_object_get_data (G_OBJECT (item), "individual");
 651
 652   update_block_menu_item (item, individual);
 653 }
 654
 655 static GtkWidget *
 656 empathy_individiual_block_menu_item_new (FolksIndividual *individual)
 657 {
 658   GtkWidget *item;
 659   GList *contacts, *l;
 660
 661   contacts = get_contacts_supporting_blocking (individual);
 662
 663   /* Can't block, no persona supports blocking */
 664   if (contacts == NULL)
 665     return NULL;
 666
 667   item = gtk_check_menu_item_new_with_mnemonic (_("_Block Contact"));
 668
 669   g_object_set_data_full (G_OBJECT (item), "individual",
 670       g_object_ref (individual), g_object_unref);
 671
 672   for (l = contacts; l != NULL; l = g_list_next (l))
 673     {
 674       TpContact *contact = l->data;
 675
 676       tp_g_signal_connect_object (contact, "notify::is-blocked",
 677           G_CALLBACK (contact_blocked_changed_cb), item, 0);
 678     }
 679
 680   g_signal_connect (item, "toggled",
 681       G_CALLBACK (empathy_individual_block_menu_item_toggled), individual);
 682
 683   update_block_menu_item (item, individual);
 684
 685   g_list_free (contacts);
 686
 687   return item;
 688 }
 689
 690 enum
 691 {
 692   REMOVE_DIALOG_RESPONSE_CANCEL = 0,
 693   REMOVE_DIALOG_RESPONSE_DELETE,
 694   REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK,
 695 };
 696
 697 static int
 698 remove_dialog_show (const gchar *message,
 699     const gchar *secondary_text,
 700     gboolean block_button,
 701     GdkPixbuf *avatar)
 702 {
 703   GtkWidget *dialog;
 704   gboolean res;
 705
 706   dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
 707       GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", message);
 708
 709   if (avatar != NULL)
 710     {
 711       GtkWidget *image = gtk_image_new_from_pixbuf (avatar);
 712       gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
 713       gtk_widget_show (image);
 714     }
 715
 716   if (block_button)
 717     {
 718       GtkWidget *button;
 719
 720       /* gtk_dialog_add_button() doesn't allow us to pass a string with a
 721        * mnemonic so we have to create the button manually. */
 722       button = gtk_button_new_with_mnemonic (
 723           _("Delete and _Block"));
 724
 725       gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
 726           REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK);
 727
 728       gtk_widget_show (button);
 729     }
 730
 731   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 732       GTK_STOCK_CANCEL, REMOVE_DIALOG_RESPONSE_CANCEL,
 733       GTK_STOCK_DELETE, REMOVE_DIALOG_RESPONSE_DELETE, NULL);
 734   gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
 735       "%s", secondary_text);
 736
 737   gtk_widget_show (dialog);
 738
 739   res = gtk_dialog_run (GTK_DIALOG (dialog));
 740   gtk_widget_destroy (dialog);
 741
 742   return res;
 743 }
 744
 745 static void
 746 remove_got_avatar (GObject *source_object,
 747     GAsyncResult *result,
 748     gpointer user_data)
 749 {
 750   FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object);
 751   GdkPixbuf *avatar;
 752   EmpathyIndividualManager *manager;
 753   gchar *text;
 754   GeeSet *personas;
 755   guint persona_count = 0;
 756   gboolean can_block;
 757   GError *error = NULL;
 758   gint res;
 759
 760   avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual,
 761       result, &error);
 762
 763   if (error != NULL)
 764     {
 765       DEBUG ("Could not get avatar: %s", error->message);
 766       g_error_free (error);
 767     }
 768
 769   /* We couldn't retrieve the avatar, but that isn't a fatal error,
 770    * so we still display the remove dialog. */
 771
 772   personas = folks_individual_get_personas (individual);
 773
 774   persona_count = gee_collection_get_size (GEE_COLLECTION (personas));
 775
 776   /* If we have more than one TpfPersona, display a different message
 777    * ensuring the user knows that *all* of the meta-contacts' personas will
 778    * be removed. */
 779
 780   if (persona_count < 2)
 781     {
 782       /* Not a meta-contact */
 783       text =
 784           g_strdup_printf (
 785               _("Do you really want to remove the contact '%s'?"),
 786               folks_alias_details_get_alias (
 787                   FOLKS_ALIAS_DETAILS (individual)));
 788     }
 789   else
 790     {
 791       /* Meta-contact */
 792       text =
 793           g_strdup_printf (
 794               _("Do you really want to remove the linked contact '%s'? "
 795                 "Note that this will remove all the contacts which make up "
 796                 "this linked contact."),
 797               folks_alias_details_get_alias (
 798                   FOLKS_ALIAS_DETAILS (individual)));
 799     }
 800
 801
 802   manager = empathy_individual_manager_dup_singleton ();
 803   can_block = empathy_individual_manager_supports_blocking (manager,
 804       individual);
 805   res = remove_dialog_show (_("Removing contact"), text, can_block, avatar);
 806
 807   if (res == REMOVE_DIALOG_RESPONSE_DELETE ||
 808       res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK)
 809     {
 810       gboolean abusive;
 811
 812       if (res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK)
 813         {
 814           if (!empathy_block_individual_dialog_show (NULL, individual,
 815                 avatar, &abusive))
 816             goto finally;
 817
 818           empathy_individual_manager_set_blocked (manager, individual,
 819               TRUE, abusive);
 820         }
 821
 822       empathy_individual_manager_remove (manager, individual, "");
 823     }
 824
 825  finally:
 826   g_free (text);
 827   g_object_unref (manager);
 828 }
 829
 830 static void
 831 remove_activate_cb (GtkMenuItem *menuitem,
 832     FolksIndividual *individual)
 833 {
 834   empathy_pixbuf_avatar_from_individual_scaled_async (individual,
 835       48, 48, NULL, remove_got_avatar, NULL);
 836 }
 837
 838 static GtkWidget *
 839 empathy_individiual_remove_menu_item_new (FolksIndividual *individual)
 840 {
 841   GeeSet *personas;
 842   GeeIterator *iter;
 843   gboolean can_remove = FALSE;
 844   GtkWidget *item, *image;
 845
 846   /* If any of the Individual's personas can be removed, add an option to
 847    * remove. This will act as a best-effort option. If any Personas cannot be
 848    * removed from the server, then this option will just be inactive upon
 849    * subsequent menu openings */
 850   personas = folks_individual_get_personas (individual);
 851   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
 852   while (!can_remove && gee_iterator_next (iter))
 853     {
 854       FolksPersona *persona = gee_iterator_get (iter);
 855       FolksPersonaStore *store = folks_persona_get_store (persona);
 856       FolksMaybeBool maybe_can_remove =
 857           folks_persona_store_get_can_remove_personas (store);
 858
 859       if (maybe_can_remove == FOLKS_MAYBE_BOOL_TRUE)
 860         can_remove = TRUE;
 861
 862       g_clear_object (&persona);
 863     }
 864   g_clear_object (&iter);
 865
 866   if (!can_remove)
 867     return NULL;
 868
 869   item = gtk_image_menu_item_new_with_mnemonic (_("_Remove"));
 870   image = gtk_image_new_from_icon_name (GTK_STOCK_REMOVE,
 871       GTK_ICON_SIZE_MENU);
 872   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 873
 874   g_signal_connect (item, "activate",
 875       G_CALLBACK (remove_activate_cb), individual);
 876
 877   return item;
 878 }
 879
 880 static void
 881 constructed (GObject *object)
 882 {
 883   EmpathyIndividualMenu *self = (EmpathyIndividualMenu *) object;
 884   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
 885   GtkMenuShell *shell;
 886   GtkWidget *item;
 887   FolksIndividual *individual;
 888   EmpathyIndividualFeatureFlags features;
 889
 890   /* Build the menu */
 891   shell = GTK_MENU_SHELL (object);
 892   individual = priv->individual;
 893   features = priv->features;
 894
 895   /* Add contact */
 896   if (features & EMPATHY_INDIVIDUAL_FEATURE_ADD_CONTACT)
 897     {
 898       item = empathy_individual_add_menu_item_new (self, individual);
 899       if (item != NULL)
 900         {
 901           gtk_menu_shell_append (GTK_MENU_SHELL (shell), item);
 902           gtk_widget_show (item);
 903         }
 904     }
 905
 906   /* Chat */
 907   if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
 908     {
 909       item = empathy_individual_chat_menu_item_new (individual);
 910       if (item != NULL)
 911         {
 912           gtk_menu_shell_append (shell, item);
 913           gtk_widget_show (item);
 914         }
 915     }
 916
 917   /* SMS */
 918   if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS)
 919     {
 920       item = empathy_individual_sms_menu_item_new (individual);
 921       if (item != NULL)
 922         {
 923           gtk_menu_shell_append (shell, item);
 924           gtk_widget_show (item);
 925         }
 926     }
 927
 928   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
 929     {
 930       /* Audio Call */
 931       item = empathy_individual_audio_call_menu_item_new (individual);
 932       gtk_menu_shell_append (shell, item);
 933       gtk_widget_show (item);
 934
 935       /* Video Call */
 936       item = empathy_individual_video_call_menu_item_new (individual);
 937       gtk_menu_shell_append (shell, item);
 938       gtk_widget_show (item);
 939     }
 940
 941   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL_PHONE)
 942     add_phone_numbers (self);
 943
 944   /* Invite */
 945   item = empathy_individual_invite_menu_item_new (individual, NULL);
 946   gtk_menu_shell_append (shell, item);
 947   gtk_widget_show (item);
 948
 949   /* File transfer */
 950   if (features & EMPATHY_INDIVIDUAL_FEATURE_FILE_TRANSFER)
 951     {
 952       item = empathy_individual_file_transfer_menu_item_new (individual);
 953       gtk_menu_shell_append (shell, item);
 954       gtk_widget_show (item);
 955     }
 956
 957   /* Share my desktop */
 958   /* FIXME we should add the "Share my desktop" menu item if Vino is
 959   a registered handler in MC5 */
 960   item = empathy_individual_share_my_desktop_menu_item_new (individual);
 961   gtk_menu_shell_append (shell, item);
 962   gtk_widget_show (item);
 963
 964   /* Menu items to target specific contacts */
 965   individual_menu_add_personas (GTK_MENU_SHELL (object), individual, features);
 966
 967   /* Separator */
 968   if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT |
 969       EMPATHY_INDIVIDUAL_FEATURE_INFO |
 970       EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE))
 971     {
 972       item = gtk_separator_menu_item_new ();
 973       gtk_menu_shell_append (shell, item);
 974       gtk_widget_show (item);
 975     }
 976
 977   /* Edit */
 978   if (features & EMPATHY_INDIVIDUAL_FEATURE_EDIT)
 979     {
 980       item = empathy_individual_edit_menu_item_new (individual);
 981       gtk_menu_shell_append (shell, item);
 982       gtk_widget_show (item);
 983     }
 984
 985   /* Log */
 986   if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
 987     {
 988       item = empathy_individual_log_menu_item_new (individual);
 989       gtk_menu_shell_append (shell, item);
 990       gtk_widget_show (item);
 991     }
 992
 993   /* Info */
 994   if (features & EMPATHY_INDIVIDUAL_FEATURE_INFO)
 995     {
 996       item = empathy_individual_info_menu_item_new (individual);
 997       gtk_menu_shell_append (shell, item);
 998       gtk_widget_show (item);
 999     }
1000
1001   /* Favorite checkbox */
1002   if (features & EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE)
1003     {
1004       item = empathy_individual_favourite_menu_item_new (individual);
1005       gtk_menu_shell_append (shell, item);
1006       gtk_widget_show (item);
1007     }
1008
1009   /* Separator & Block */
1010   if (features & EMPATHY_INDIVIDUAL_FEATURE_BLOCK &&
1011       (item = empathy_individiual_block_menu_item_new (individual)) != NULL) {
1012     GtkWidget *sep;
1013
1014     sep = gtk_separator_menu_item_new ();
1015     gtk_menu_shell_append (shell, sep);
1016     gtk_widget_show (sep);
1017
1018     gtk_menu_shell_append (shell, item);
1019     gtk_widget_show (item);
1020   }
1021
1022   /* Separator & Remove */
1023   if (features & EMPATHY_INDIVIDUAL_FEATURE_REMOVE &&
1024       (item = empathy_individiual_remove_menu_item_new (individual)) != NULL) {
1025     GtkWidget *sep;
1026
1027     sep = gtk_separator_menu_item_new ();
1028     gtk_menu_shell_append (shell, sep);
1029     gtk_widget_show (sep);
1030
1031     gtk_menu_shell_append (shell, item);
1032     gtk_widget_show (item);
1033   }
1034 }
1035
1036 static void
1037 get_property (GObject *object,
1038     guint param_id,
1039     GValue *value,
1040     GParamSpec *pspec)
1041 {
1042   EmpathyIndividualMenuPriv *priv;
1043
1044   priv = GET_PRIV (object);
1045
1046   switch (param_id)
1047     {
1048       case PROP_INDIVIDUAL:
1049         g_value_set_object (value, priv->individual);
1050         break;
1051       case PROP_FEATURES:
1052         g_value_set_flags (value, priv->features);
1053         break;
1054       case PROP_STORE:
1055         g_value_set_object (value, priv->store);
1056         break;
1057       default:
1058         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1059         break;
1060     }
1061 }
1062
1063 static void
1064 set_property (GObject *object,
1065     guint param_id,
1066     const GValue *value,
1067     GParamSpec *pspec)
1068 {
1069   EmpathyIndividualMenuPriv *priv;
1070
1071   priv = GET_PRIV (object);
1072
1073   switch (param_id)
1074     {
1075       case PROP_INDIVIDUAL:
1076         priv->individual = g_value_dup_object (value);
1077         break;
1078       case PROP_FEATURES:
1079         priv->features = g_value_get_flags (value);
1080         break;
1081       case PROP_STORE:
1082         priv->store = g_value_dup_object (value); /* read only */
1083         break;
1084       default:
1085         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1086         break;
1087     }
1088 }
1089
1090 static void
1091 dispose (GObject *object)
1092 {
1093   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
1094
1095   tp_clear_object (&priv->individual);
1096   tp_clear_object (&priv->store);
1097
1098   G_OBJECT_CLASS (empathy_individual_menu_parent_class)->dispose (object);
1099 }
1100
1101 static void
1102 empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass)
1103 {
1104   GObjectClass *object_class = G_OBJECT_CLASS (klass);
1105
1106   object_class->constructed = constructed;
1107   object_class->get_property = get_property;
1108   object_class->set_property = set_property;
1109   object_class->dispose = dispose;
1110
1111   /**
1112    * EmpathyIndividualMenu:individual:
1113    *
1114    * The #FolksIndividual the menu is for.
1115    */
1116   g_object_class_install_property (object_class, PROP_INDIVIDUAL,
1117       g_param_spec_object ("individual",
1118           "Individual",
1119           "The #FolksIndividual the menu is for.",
1120           FOLKS_TYPE_INDIVIDUAL,
1121           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1122
1123   /**
1124    * EmpathyIndividualMenu:features:
1125    *
1126    * A set of feature flags controlling which entries are shown.
1127    */
1128   g_object_class_install_property (object_class, PROP_FEATURES,
1129       g_param_spec_flags ("features",
1130           "Features",
1131           "A set of feature flags controlling which entries are shown.",
1132           EMPATHY_TYPE_INDIVIDUAL_FEATURE_FLAGS,
1133           EMPATHY_INDIVIDUAL_FEATURE_NONE,
1134           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1135
1136   g_object_class_install_property (object_class, PROP_STORE,
1137       g_param_spec_object ("store",
1138           "Store",
1139           "The EmpathyIndividualStore to use to get contact owner",
1140           EMPATHY_TYPE_INDIVIDUAL_STORE,
1141           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
1142
1143   g_type_class_add_private (object_class, sizeof (EmpathyIndividualMenuPriv));
1144 }
1145
1146 GtkWidget *
1147 empathy_individual_menu_new (FolksIndividual *individual,
1148     EmpathyIndividualFeatureFlags features,
1149     EmpathyIndividualStore *store)
1150 {
1151   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1152   g_return_val_if_fail (store == NULL ||
1153       EMPATHY_IS_INDIVIDUAL_STORE (store), NULL);
1154   g_return_val_if_fail (features != EMPATHY_INDIVIDUAL_FEATURE_NONE, NULL);
1155
1156   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MENU,
1157       "individual", individual,
1158       "features", features,
1159       "store", store,
1160       NULL);
1161 }
1162
1163 /* Like menu_item_set_first_contact(), but always operates upon the given
1164  * contact. If the contact is non-NULL, it is assumed that the menu entry should
1165  * be sensitive. */
1166 static gboolean
1167 menu_item_set_contact (GtkWidget *item,
1168     EmpathyContact *contact,
1169     GCallback activate_callback,
1170     EmpathyActionType action_type)
1171 {
1172   gboolean can_do_action = FALSE;
1173
1174   if (contact != NULL)
1175     can_do_action = empathy_contact_can_do_action (contact, action_type);
1176   gtk_widget_set_sensitive (item, can_do_action);
1177
1178   if (can_do_action == TRUE)
1179     {
1180       /* We want to make sure that the EmpathyContact stays alive while the
1181        * signal is connected. */
1182       g_signal_connect_data (item, "activate", G_CALLBACK (activate_callback),
1183           g_object_ref (contact), (GClosureNotify) g_object_unref, 0);
1184     }
1185
1186   return can_do_action;
1187 }
1188
1189 /**
1190  * Set the given menu @item to call @activate_callback using the TpContact
1191  * (associated with @individual) with the highest availability who is also valid
1192  * whenever @item is activated.
1193  *
1194  * @action_type is the type of action performed by the menu entry; this is used
1195  * so that only contacts which can perform that action (e.g. are capable of
1196  * receiving video calls) are selected, as appropriate.
1197  */
1198 static GtkWidget *
1199 menu_item_set_first_contact (GtkWidget *item,
1200     FolksIndividual *individual,
1201     GCallback activate_callback,
1202     EmpathyActionType action_type)
1203 {
1204   EmpathyContact *best_contact;
1205
1206   best_contact = empathy_contact_dup_best_for_action (individual, action_type);
1207   menu_item_set_contact (item, best_contact, G_CALLBACK (activate_callback),
1208       action_type);
1209   tp_clear_object (&best_contact);
1210
1211   return item;
1212 }
1213
1214 static void
1215 empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
1216   EmpathyContact *contact)
1217 {
1218   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1219
1220   empathy_chat_with_contact (contact, empathy_get_current_action_time ());
1221 }
1222
1223 static GtkWidget *
1224 empathy_individual_chat_menu_item_new (FolksIndividual *individual)
1225 {
1226   GtkWidget *item;
1227   GtkWidget *image;
1228
1229   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) &&
1230       empathy_folks_individual_contains_contact (individual), NULL);
1231
1232   item = gtk_image_menu_item_new_with_mnemonic (_("_Chat"));
1233   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE,
1234       GTK_ICON_SIZE_MENU);
1235   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1236   gtk_widget_show (image);
1237
1238   menu_item_set_first_contact (item, individual,
1239       G_CALLBACK (empathy_individual_chat_menu_item_activated),
1240       EMPATHY_ACTION_CHAT);
1241
1242   return item;
1243 }
1244
1245 static void
1246 empathy_individual_sms_menu_item_activated (GtkMenuItem *item,
1247   EmpathyContact *contact)
1248 {
1249   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1250
1251   empathy_sms_contact_id (
1252       empathy_contact_get_account (contact),
1253       empathy_contact_get_id (contact),
1254       empathy_get_current_action_time (),
1255       NULL, NULL);
1256 }
1257
1258 static GtkWidget *
1259 empathy_individual_sms_menu_item_new (FolksIndividual *individual)
1260 {
1261   GtkWidget *item;
1262   GtkWidget *image;
1263
1264   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) &&
1265       empathy_folks_individual_contains_contact (individual), NULL);
1266
1267   item = gtk_image_menu_item_new_with_mnemonic (_("_SMS"));
1268   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS,
1269       GTK_ICON_SIZE_MENU);
1270   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1271   gtk_widget_show (image);
1272
1273   menu_item_set_first_contact (item, individual,
1274       G_CALLBACK (empathy_individual_sms_menu_item_activated),
1275       EMPATHY_ACTION_SMS);
1276
1277   return item;
1278 }
1279
1280 static void
1281 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
1282   EmpathyContact *contact)
1283 {
1284   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1285
1286   empathy_call_new_with_streams (empathy_contact_get_id (contact),
1287       empathy_contact_get_account (contact),
1288       TRUE, FALSE,
1289       empathy_get_current_action_time ());
1290 }
1291
1292 GtkWidget *
1293 empathy_individual_audio_call_menu_item_new (FolksIndividual *individual)
1294 {
1295   GtkWidget *item;
1296   GtkWidget *image;
1297
1298   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1299
1300   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
1301   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
1302   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1303   gtk_widget_show (image);
1304
1305   menu_item_set_first_contact (item, individual,
1306       G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
1307       EMPATHY_ACTION_AUDIO_CALL);
1308
1309   return item;
1310 }
1311
1312 static void
1313 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
1314   EmpathyContact *contact)
1315 {
1316   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1317
1318   empathy_call_new_with_streams (empathy_contact_get_id (contact),
1319       empathy_contact_get_account (contact),
1320       TRUE, TRUE,
1321       empathy_get_current_action_time ());
1322 }
1323
1324 GtkWidget *
1325 empathy_individual_video_call_menu_item_new (FolksIndividual *individual)
1326 {
1327   GtkWidget *item;
1328   GtkWidget *image;
1329   EmpathyCameraMonitor *monitor;
1330
1331   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1332
1333   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
1334   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
1335       GTK_ICON_SIZE_MENU);
1336   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1337   gtk_widget_show (image);
1338
1339   menu_item_set_first_contact (item, individual,
1340       G_CALLBACK (empathy_individual_video_call_menu_item_activated),
1341       EMPATHY_ACTION_VIDEO_CALL);
1342
1343   /* Only follow available cameras if the contact can do Video calls */
1344   if (gtk_widget_get_sensitive (item))
1345     {
1346       monitor = empathy_camera_monitor_dup_singleton ();
1347       g_object_set_data_full (G_OBJECT (item),
1348           "monitor", monitor, g_object_unref);
1349       g_object_bind_property (monitor, "available", item, "sensitive",
1350           G_BINDING_SYNC_CREATE);
1351     }
1352
1353   return item;
1354 }
1355
1356 static void
1357 empathy_individual_log_menu_item_activated (GtkMenuItem *item,
1358   EmpathyContact *contact)
1359 {
1360   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1361
1362   empathy_log_window_show (empathy_contact_get_account (contact),
1363       empathy_contact_get_id (contact), FALSE, NULL);
1364 }
1365
1366 static GtkWidget *
1367 empathy_individual_log_menu_item_new (FolksIndividual *individual)
1368 {
1369   GtkWidget *item;
1370   GtkWidget *image;
1371
1372   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1373
1374   item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations"));
1375   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU);
1376   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1377   gtk_widget_show (image);
1378
1379   menu_item_set_first_contact (item, individual,
1380       G_CALLBACK (empathy_individual_log_menu_item_activated),
1381       EMPATHY_ACTION_VIEW_LOGS);
1382
1383   return item;
1384 }
1385
1386 static void
1387 empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
1388     EmpathyContact *contact)
1389 {
1390   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1391
1392   empathy_send_file_with_file_chooser (contact);
1393 }
1394
1395 static GtkWidget *
1396 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual)
1397 {
1398   GtkWidget *item;
1399   GtkWidget *image;
1400
1401   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1402
1403   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
1404   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
1405       GTK_ICON_SIZE_MENU);
1406   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1407   gtk_widget_show (image);
1408
1409   menu_item_set_first_contact (item, individual,
1410       G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
1411       EMPATHY_ACTION_SEND_FILE);
1412
1413   return item;
1414 }
1415
1416 static void
1417 empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item,
1418     EmpathyContact *contact)
1419 {
1420   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1421
1422   empathy_share_my_desktop_share_with_contact (contact);
1423 }
1424
1425 static GtkWidget *
1426 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual)
1427 {
1428   GtkWidget *item;
1429   GtkWidget *image;
1430
1431   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1432
1433   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
1434   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
1435   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1436   gtk_widget_show (image);
1437
1438   menu_item_set_first_contact (item, individual,
1439       G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1440       EMPATHY_ACTION_SHARE_MY_DESKTOP);
1441
1442   return item;
1443 }
1444
1445 static void
1446 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
1447   FolksIndividual *individual)
1448 {
1449   folks_favourite_details_set_is_favourite (
1450       FOLKS_FAVOURITE_DETAILS (individual),
1451       gtk_check_menu_item_get_active (item));
1452 }
1453
1454 static GtkWidget *
1455 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
1456 {
1457   GtkWidget *item;
1458
1459   item = gtk_check_menu_item_new_with_label (_("Favorite"));
1460
1461   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
1462       folks_favourite_details_get_is_favourite (
1463           FOLKS_FAVOURITE_DETAILS (individual)));
1464
1465   g_signal_connect (item, "toggled",
1466       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
1467
1468   return item;
1469 }
1470
1471 static void
1472 individual_info_menu_item_activate_cb (GtkMenuItem *item,
1473     FolksIndividual *individual)
1474 {
1475   empathy_display_individual_info (individual);
1476 }
1477
1478 static GtkWidget *
1479 empathy_individual_info_menu_item_new (FolksIndividual *individual)
1480 {
1481   GtkWidget *item;
1482   GtkWidget *image;
1483
1484   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1485   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
1486       NULL);
1487
1488   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
1489   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
1490                 GTK_ICON_SIZE_MENU);
1491   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1492   gtk_widget_show (image);
1493
1494   g_signal_connect (item, "activate",
1495           G_CALLBACK (individual_info_menu_item_activate_cb),
1496           individual);
1497
1498   return item;
1499 }
1500
1501 static void
1502 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
1503 {
1504   empathy_individual_edit_dialog_show (individual, NULL);
1505 }
1506
1507 static GtkWidget *
1508 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
1509 {
1510   EmpathyIndividualManager *manager;
1511   GtkWidget *item;
1512   GtkWidget *image;
1513   gboolean enable = FALSE;
1514   EmpathyContact *contact;
1515
1516   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1517
1518   contact = empathy_contact_dup_from_folks_individual (individual);
1519
1520   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
1521
1522   if (empathy_individual_manager_initialized ())
1523     {
1524       TpConnection *connection;
1525
1526       manager = empathy_individual_manager_dup_singleton ();
1527       connection = empathy_contact_get_connection (contact);
1528
1529       enable = (empathy_connection_can_alias_personas (connection,
1530                                                        individual) &&
1531                 empathy_connection_can_group_personas (connection, individual));
1532
1533       g_object_unref (manager);
1534     }
1535
1536   item = gtk_image_menu_item_new_with_mnemonic (
1537       C_("Edit individual (contextual menu)", "_Edit"));
1538   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1539   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1540   gtk_widget_show (image);
1541
1542   gtk_widget_set_sensitive (item, enable);
1543
1544   g_signal_connect_swapped (item, "activate",
1545       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
1546
1547   g_object_unref (contact);
1548
1549   return item;
1550 }
1551
1552 typedef struct
1553 {
1554   FolksIndividual *individual;
1555   EmpathyContact *contact;
1556   EmpathyChatroom *chatroom;
1557 } RoomSubMenuData;
1558
1559 static RoomSubMenuData *
1560 room_sub_menu_data_new (FolksIndividual *individual,
1561     EmpathyContact *contact,
1562     EmpathyChatroom *chatroom)
1563 {
1564   RoomSubMenuData *data;
1565
1566   data = g_slice_new0 (RoomSubMenuData);
1567   if (individual != NULL)
1568     data->individual = g_object_ref (individual);
1569   if (contact != NULL)
1570     data->contact = g_object_ref (contact);
1571   data->chatroom = g_object_ref (chatroom);
1572
1573   return data;
1574 }
1575
1576 static void
1577 room_sub_menu_data_free (RoomSubMenuData *data)
1578 {
1579   tp_clear_object (&data->individual);
1580   tp_clear_object (&data->contact);
1581   g_object_unref (data->chatroom);
1582   g_slice_free (RoomSubMenuData, data);
1583 }
1584
1585 static void
1586 room_sub_menu_activate_cb (GtkWidget *item,
1587          RoomSubMenuData *data)
1588 {
1589   EmpathyTpChat *chat;
1590   EmpathyChatroomManager *mgr;
1591   EmpathyContact *contact = NULL;
1592
1593   chat = empathy_chatroom_get_tp_chat (data->chatroom);
1594   if (chat == NULL)
1595     {
1596       /* channel was invalidated. Ignoring */
1597       return;
1598     }
1599
1600   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1601
1602   if (data->contact != NULL)
1603     contact = g_object_ref (data->contact);
1604   else
1605     {
1606       GeeSet *personas;
1607       GeeIterator *iter;
1608
1609       /* find the first of this Individual's contacts who can join this room */
1610       personas = folks_individual_get_personas (data->individual);
1611
1612       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1613       while (gee_iterator_next (iter) && (contact == NULL))
1614         {
1615           TpfPersona *persona = gee_iterator_get (iter);
1616           TpContact *tp_contact;
1617           GList *rooms;
1618
1619           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1620             {
1621               tp_contact = tpf_persona_get_contact (persona);
1622               if (tp_contact != NULL)
1623                 {
1624                   contact = empathy_contact_dup_from_tp_contact (tp_contact);
1625
1626                   rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1627                       empathy_contact_get_account (contact));
1628
1629                   if (g_list_find (rooms, data->chatroom) == NULL)
1630                     g_clear_object (&contact);
1631
1632                   /* if contact != NULL here, we've found our match */
1633
1634                   g_list_free (rooms);
1635                 }
1636             }
1637           g_clear_object (&persona);
1638         }
1639       g_clear_object (&iter);
1640     }
1641
1642   g_object_unref (mgr);
1643
1644   if (contact == NULL)
1645     {
1646       /* contact disappeared. Ignoring */
1647       goto out;
1648     }
1649
1650   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1651
1652   /* send invitation */
1653   empathy_tp_chat_add (chat, contact, _("Inviting you to this room"));
1654
1655 out:
1656   g_object_unref (contact);
1657 }
1658
1659 static GtkWidget *
1660 create_room_sub_menu (FolksIndividual *individual,
1661                       EmpathyContact *contact,
1662                       EmpathyChatroom *chatroom)
1663 {
1664   GtkWidget *item;
1665   RoomSubMenuData *data;
1666
1667   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
1668   data = room_sub_menu_data_new (individual, contact, chatroom);
1669   g_signal_connect_data (item, "activate",
1670       G_CALLBACK (room_sub_menu_activate_cb), data,
1671       (GClosureNotify) room_sub_menu_data_free, 0);
1672
1673   return item;
1674 }
1675
1676 static GtkWidget *
1677 empathy_individual_invite_menu_item_new (FolksIndividual *individual,
1678     EmpathyContact *contact)
1679 {
1680   GtkWidget *item;
1681   GtkWidget *image;
1682   GtkWidget *room_item;
1683   EmpathyChatroomManager *mgr;
1684   GList *rooms = NULL;
1685   GList *names = NULL;
1686   GList *l;
1687   GtkWidget *submenu = NULL;
1688   /* map of chat room names to their objects; just a utility to remove
1689    * duplicates and to make construction of the alphabetized list easier */
1690   GHashTable *name_room_map;
1691
1692   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1693       EMPATHY_IS_CONTACT (contact),
1694       NULL);
1695
1696   name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
1697       g_object_unref);
1698
1699   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
1700   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
1701       GTK_ICON_SIZE_MENU);
1702   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1703
1704   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1705
1706   if (contact != NULL)
1707     {
1708       rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1709           empathy_contact_get_account (contact));
1710     }
1711   else
1712     {
1713       GeeSet *personas;
1714       GeeIterator *iter;
1715
1716       /* find the first of this Individual's contacts who can join this room */
1717       personas = folks_individual_get_personas (individual);
1718       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1719       while (gee_iterator_next (iter))
1720         {
1721           TpfPersona *persona = gee_iterator_get (iter);
1722           GList *rooms_cur;
1723           TpContact *tp_contact;
1724           EmpathyContact *contact_cur;
1725
1726           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1727             {
1728               tp_contact = tpf_persona_get_contact (persona);
1729               if (tp_contact != NULL)
1730                 {
1731                   contact_cur = empathy_contact_dup_from_tp_contact (
1732                       tp_contact);
1733
1734                   rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
1735                       empathy_contact_get_account (contact_cur));
1736                   rooms = g_list_concat (rooms, rooms_cur);
1737
1738                   g_object_unref (contact_cur);
1739                 }
1740             }
1741           g_clear_object (&persona);
1742         }
1743       g_clear_object (&iter);
1744     }
1745
1746   /* alphabetize the rooms */
1747   for (l = rooms; l != NULL; l = g_list_next (l))
1748     {
1749       EmpathyChatroom *chatroom = l->data;
1750       gboolean existed;
1751
1752       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
1753         {
1754           const gchar *name;
1755
1756           name = empathy_chatroom_get_name (chatroom);
1757           existed = (g_hash_table_lookup (name_room_map, name) != NULL);
1758           g_hash_table_insert (name_room_map, (gpointer) name,
1759               g_object_ref (chatroom));
1760
1761           /* this will take care of duplicates in rooms */
1762           if (!existed)
1763             {
1764               names = g_list_insert_sorted (names, (gpointer) name,
1765                   (GCompareFunc) g_strcmp0);
1766             }
1767         }
1768     }
1769
1770   for (l = names; l != NULL; l = g_list_next (l))
1771     {
1772       const gchar *name = l->data;
1773       EmpathyChatroom *chatroom;
1774
1775       if (G_UNLIKELY (submenu == NULL))
1776         submenu = gtk_menu_new ();
1777
1778       chatroom = g_hash_table_lookup (name_room_map, name);
1779       room_item = create_room_sub_menu (individual, contact, chatroom);
1780       gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
1781       gtk_widget_show (room_item);
1782     }
1783
1784   if (submenu)
1785     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
1786   else
1787     gtk_widget_set_sensitive (item, FALSE);
1788
1789   gtk_widget_show (image);
1790
1791   g_hash_table_unref (name_room_map);
1792   g_object_unref (mgr);
1793   g_list_free (names);
1794   g_list_free (rooms);
1795
1796   return item;
1797 }
1798
1799 static void
1800 add_menu_item_activated (GtkMenuItem *item,
1801     TpContact *tp_contact)
1802 {
1803   GtkWidget *toplevel;
1804   FolksIndividual *individual;
1805
1806   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (item));
1807   if (!gtk_widget_is_toplevel (toplevel) || !GTK_IS_WINDOW (toplevel))
1808     toplevel = NULL;
1809
1810   individual = empathy_ensure_individual_from_tp_contact (tp_contact);
1811
1812   empathy_new_individual_dialog_show_with_individual (GTK_WINDOW (toplevel),
1813       individual);
1814
1815   g_object_unref (individual);
1816 }
1817
1818 static GtkWidget *
1819 empathy_individual_add_menu_item_new (EmpathyIndividualMenu *self,
1820     FolksIndividual *individual)
1821 {
1822   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
1823   GtkWidget *item, *image;
1824   GeeSet *personas;
1825   GeeIterator *iter;
1826   TpContact *to_add = NULL;
1827
1828   /* find the first of this Individual's personas which are not in our contact
1829    * list. */
1830   personas = folks_individual_get_personas (individual);
1831   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1832   while (gee_iterator_next (iter))
1833     {
1834       TpfPersona *persona = gee_iterator_get (iter);
1835       TpContact *contact;
1836       TpConnection *conn;
1837
1838       if (!TPF_IS_PERSONA (persona))
1839         goto next;
1840
1841       contact = tpf_persona_get_contact (persona);
1842       if (contact == NULL)
1843         goto next;
1844
1845       /* be sure to use a not channel specific contact.
1846        * TODO: Ideally tp-glib should do this for us (fdo #42702)*/
1847       if (EMPATHY_IS_INDIVIDUAL_STORE_CHANNEL (priv->store))
1848         {
1849           TpChannel *channel;
1850           TpChannelGroupFlags flags;
1851
1852           channel = empathy_individual_store_channel_get_channel (
1853               EMPATHY_INDIVIDUAL_STORE_CHANNEL (priv->store));
1854
1855           flags = tp_channel_group_get_flags (channel);
1856           if ((flags & TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES) != 0)
1857             {
1858               /* Channel uses channel specific handles (thanks XMPP...) */
1859               contact = tp_channel_group_get_contact_owner (channel, contact);
1860
1861               /* If we don't know the owner, we can't add the contact */
1862               if (contact == NULL)
1863                 goto next;
1864             }
1865         }
1866
1867       conn = tp_contact_get_connection (contact);
1868       if (conn == NULL)
1869         goto next;
1870
1871       /* No point to try adding a contact if the CM doesn't support it */
1872       if (!tp_connection_get_can_change_contact_list (conn))
1873         goto next;
1874
1875       /* Can't add ourself */
1876       if (tp_connection_get_self_contact (conn) == contact)
1877         goto next;
1878
1879       if (tp_contact_get_subscribe_state (contact) == TP_SUBSCRIPTION_STATE_YES)
1880         goto next;
1881
1882       g_object_unref (persona);
1883       to_add = contact;
1884       break;
1885
1886 next:
1887       g_object_unref (persona);
1888     }
1889
1890   g_object_unref (iter);
1891
1892   if (to_add == NULL)
1893     return NULL;
1894
1895   item = gtk_image_menu_item_new_with_mnemonic (_("_Add Contact…"));
1896   image = gtk_image_new_from_icon_name (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
1897   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1898
1899   g_signal_connect_data (item, "activate",
1900       G_CALLBACK (add_menu_item_activated),
1901       g_object_ref (to_add), (GClosureNotify) g_object_unref, 0);
1902
1903   return item;
1904 }