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 <telepathy-glib/util.h>
  30
  31 #include <folks/folks.h>
  32 #include <folks/folks-telepathy.h>
  33
  34 #include <libempathy/empathy-camera-monitor.h>
  35 #include <libempathy/empathy-request-util.h>
  36 #include <libempathy/empathy-individual-manager.h>
  37 #include <libempathy/empathy-chatroom-manager.h>
  38 #include <libempathy/empathy-utils.h>
  39
  40 #include "empathy-account-selector-dialog.h"
  41 #include "empathy-individual-menu.h"
  42 #include "empathy-images.h"
  43 #include "empathy-log-window.h"
  44 #include "empathy-contact-dialogs.h"
  45 #include "empathy-gtk-enum-types.h"
  46 #include "empathy-individual-edit-dialog.h"
  47 #include "empathy-individual-information-dialog.h"
  48 #include "empathy-ui-utils.h"
  49 #include "empathy-share-my-desktop.h"
  50 #include "empathy-linking-dialog.h"
  51 #include "empathy-call-utils.h"
  52
  53 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  54 #include <libempathy/empathy-debug.h>
  55
  56 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualMenu)
  57
  58 typedef struct {
  59   FolksIndividual *individual; /* owned */
  60   EmpathyIndividualFeatureFlags features;
  61 } EmpathyIndividualMenuPriv;
  62
  63 enum {
  64   PROP_INDIVIDUAL = 1,
  65   PROP_FEATURES,
  66 };
  67
  68 enum {
  69   SIGNAL_LINK_CONTACTS_ACTIVATED,
  70   LAST_SIGNAL
  71 };
  72
  73 static guint signals[LAST_SIGNAL];
  74
  75 G_DEFINE_TYPE (EmpathyIndividualMenu, empathy_individual_menu, GTK_TYPE_MENU);
  76
  77 static void
  78 individual_menu_add_personas (GtkMenuShell *menu,
  79     FolksIndividual *individual,
  80     EmpathyIndividualFeatureFlags features)
  81 {
  82   GtkWidget *item;
  83   GeeSet *personas;
  84   GeeIterator *iter;
  85   guint persona_count = 0;
  86   gboolean c;
  87
  88   g_return_if_fail (GTK_IS_MENU (menu));
  89   g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
  90   g_return_if_fail (empathy_folks_individual_contains_contact (individual));
  91
  92   personas = folks_individual_get_personas (individual);
  93   /* we'll re-use this iterator throughout */
  94   iter = gee_iterable_iterator (GEE_ITERABLE (personas));
  95
  96   /* Make sure we've got enough valid entries for these menu items to add
  97    * functionality */
  98   while (gee_iterator_next (iter))
  99     {
 100       FolksPersona *persona = gee_iterator_get (iter);
 101       if (empathy_folks_persona_is_interesting (persona))
 102         persona_count++;
 103
 104       g_clear_object (&persona);
 105     }
 106
 107   /* return early if these entries would add nothing beyond the "quick" items */
 108   if (persona_count <= 1)
 109     return;
 110
 111   /* add a separator before the list of personas */
 112   item = gtk_separator_menu_item_new ();
 113   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 114   gtk_widget_show (item);
 115
 116   personas = folks_individual_get_personas (individual);
 117   for (c = gee_iterator_first (iter); c; c = gee_iterator_next (iter))
 118     {
 119       GtkWidget *image;
 120       GtkWidget *contact_item;
 121       GtkWidget *contact_submenu;
 122       TpContact *tp_contact;
 123       EmpathyContact *contact;
 124       TpfPersona *persona = gee_iterator_get (iter);
 125       gchar *label;
 126       FolksPersonaStore *store;
 127       const gchar *account;
 128       GtkWidget *action;
 129
 130       if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
 131         goto while_finish;
 132
 133       tp_contact = tpf_persona_get_contact (persona);
 134       if (tp_contact == NULL)
 135         goto while_finish;
 136
 137       contact = empathy_contact_dup_from_tp_contact (tp_contact);
 138
 139       store = folks_persona_get_store (FOLKS_PERSONA (persona));
 140       account = folks_persona_store_get_display_name (store);
 141
 142       /* Translators: this is used in the context menu for a contact. The first
 143        * parameter is a contact ID (e.g. foo@jabber.org) and the second is one
 144        * of the user's account IDs (e.g. me@hotmail.com). */
 145       label = g_strdup_printf (_("%s (%s)"),
 146           folks_persona_get_display_id (FOLKS_PERSONA (persona)), account);
 147
 148       contact_item = gtk_image_menu_item_new_with_label (label);
 149       gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (contact_item),
 150                                                  TRUE);
 151       contact_submenu = gtk_menu_new ();
 152       gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_item), contact_submenu);
 153       image = gtk_image_new_from_icon_name (
 154           empathy_icon_name_for_contact (contact), GTK_ICON_SIZE_MENU);
 155       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (contact_item), image);
 156       gtk_widget_show (image);
 157
 158       /* Chat */
 159       if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
 160         {
 161           action = empathy_individual_chat_menu_item_new (NULL, contact);
 162           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 163           gtk_widget_show (action);
 164         }
 165
 166       /* SMS */
 167       if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS)
 168         {
 169           action = empathy_individual_sms_menu_item_new (NULL, contact);
 170           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 171           gtk_widget_show (action);
 172         }
 173
 174       if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
 175         {
 176           /* Audio Call */
 177           action = empathy_individual_audio_call_menu_item_new (NULL, contact);
 178           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 179           gtk_widget_show (action);
 180
 181           /* Video Call */
 182           action = empathy_individual_video_call_menu_item_new (NULL, contact);
 183           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 184           gtk_widget_show (action);
 185         }
 186
 187       /* Log */
 188       if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
 189         {
 190           action = empathy_individual_log_menu_item_new (NULL, contact);
 191           gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 192           gtk_widget_show (action);
 193         }
 194
 195       /* Invite */
 196       action = empathy_individual_invite_menu_item_new (NULL, contact);
 197       gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 198       gtk_widget_show (action);
 199
 200       /* File transfer */
 201       action = empathy_individual_file_transfer_menu_item_new (NULL, contact);
 202       gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 203       gtk_widget_show (action);
 204
 205       /* Share my desktop */
 206       action = empathy_individual_share_my_desktop_menu_item_new (NULL,
 207           contact);
 208       gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
 209       gtk_widget_show (action);
 210
 211       gtk_menu_shell_append (GTK_MENU_SHELL (menu), contact_item);
 212       gtk_widget_show (contact_item);
 213
 214       g_free (label);
 215       g_object_unref (contact);
 216
 217 while_finish:
 218       g_clear_object (&persona);
 219     }
 220
 221   g_clear_object (&iter);
 222 }
 223
 224 static void
 225 individual_link_menu_item_activate_cb (EmpathyIndividualMenu *self)
 226 {
 227   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 228   GtkWidget *dialog;
 229
 230   dialog = empathy_linking_dialog_show (priv->individual, NULL);
 231   g_signal_emit (self, signals[SIGNAL_LINK_CONTACTS_ACTIVATED], 0, dialog);
 232 }
 233
 234 static void
 235 empathy_individual_menu_init (EmpathyIndividualMenu *self)
 236 {
 237   EmpathyIndividualMenuPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 238       EMPATHY_TYPE_INDIVIDUAL_MENU, EmpathyIndividualMenuPriv);
 239
 240   self->priv = priv;
 241 }
 242
 243 static GList *
 244 find_phone_accounts (void)
 245 {
 246   TpAccountManager *am;
 247   GList *accounts, *l;
 248   GList *found = NULL;
 249
 250   am = tp_account_manager_dup ();
 251   g_return_val_if_fail (am != NULL, NULL);
 252
 253   accounts = tp_account_manager_get_valid_accounts (am);
 254   for (l = accounts; l != NULL; l = g_list_next (l))
 255     {
 256       TpAccount *account = l->data;
 257
 258       if (tp_account_get_connection_status (account, NULL) !=
 259           TP_CONNECTION_STATUS_CONNECTED)
 260         continue;
 261
 262       if (!empathy_account_has_uri_scheme_tel (account))
 263         continue;
 264
 265       found = g_list_prepend (found, g_object_ref (account));
 266     }
 267
 268   g_list_free (accounts);
 269   g_object_unref (am);
 270
 271   return found;
 272 }
 273
 274 static gboolean
 275 has_phone_account (void)
 276 {
 277   GList *accounts;
 278   gboolean result;
 279
 280   accounts = find_phone_accounts ();
 281   result = (accounts != NULL);
 282
 283   g_list_free_full (accounts, (GDestroyNotify) g_object_unref);
 284
 285   return result;
 286 }
 287
 288 static void
 289 call_phone_number (FolksPhoneFieldDetails *details,
 290     TpAccount *account)
 291 {
 292   DEBUG ("Try to call %s", folks_phone_field_details_get_normalised (details));
 293
 294   empathy_call_new_with_streams (
 295       folks_phone_field_details_get_normalised (details),
 296       account, TRUE, FALSE, empathy_get_current_action_time ());
 297 }
 298
 299 static void
 300 display_call_phone_dialog (FolksPhoneFieldDetails *details,
 301     GList *accounts)
 302 {
 303   GtkWidget *dialog;
 304   gint response;
 305
 306   dialog = empathy_account_selector_dialog_new (accounts);
 307
 308   gtk_window_set_title (GTK_WINDOW (dialog),
 309       _("Select account to use to place the call"));
 310
 311   gtk_dialog_add_buttons (GTK_DIALOG (dialog),
 312       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 313       _("Call"), GTK_RESPONSE_OK,
 314       NULL);
 315
 316   response = gtk_dialog_run (GTK_DIALOG (dialog));
 317
 318   if (response == GTK_RESPONSE_OK)
 319     {
 320       TpAccount *account;
 321
 322       account = empathy_account_selector_dialog_dup_selected (
 323            EMPATHY_ACCOUNT_SELECTOR_DIALOG (dialog));
 324
 325       if (account != NULL)
 326         {
 327           call_phone_number (details, account);
 328
 329           g_object_unref (account);
 330         }
 331     }
 332
 333   gtk_widget_destroy (dialog);
 334 }
 335
 336 static void
 337 call_phone_number_cb (GtkMenuItem *item,
 338       FolksPhoneFieldDetails *details)
 339 {
 340   GList *accounts;
 341
 342   accounts = find_phone_accounts ();
 343   if (accounts == NULL)
 344     {
 345       DEBUG ("No phone aware account connected; can't call");
 346     }
 347   else if (g_list_length (accounts) == 1)
 348     {
 349       call_phone_number (details, accounts->data);
 350     }
 351   else
 352     {
 353       /* Ask which account to use */
 354       display_call_phone_dialog (details, accounts);
 355     }
 356
 357   g_list_free_full (accounts, (GDestroyNotify) g_object_unref);
 358 }
 359
 360 static const gchar *
 361 find_phone_type (FolksPhoneFieldDetails *details)
 362 {
 363   GeeCollection *types;
 364   GeeIterator *iter;
 365
 366   types = folks_abstract_field_details_get_parameter_values (
 367       FOLKS_ABSTRACT_FIELD_DETAILS (details), "type");
 368
 369   if (types == NULL)
 370     return NULL;
 371
 372   iter = gee_iterable_iterator (GEE_ITERABLE (types));
 373   while (gee_iterator_next (iter))
 374     {
 375       const gchar *type = gee_iterator_get (iter);
 376
 377       if (!tp_strdiff (type, "CELL"))
 378         return _("Mobile");
 379       else if (!tp_strdiff (type, "WORK"))
 380         return _("Work");
 381       else if (!tp_strdiff (type, "HOME"))
 382         return _("HOME");
 383     }
 384
 385   return NULL;
 386 }
 387
 388 static void
 389 add_phone_numbers (EmpathyIndividualMenu *self)
 390 {
 391   EmpathyIndividualMenuPriv *priv = GET_PRIV (self);
 392   GeeSet *all_numbers;
 393   GeeIterator *iter;
 394   gboolean sensitive;
 395
 396   all_numbers = folks_phone_details_get_phone_numbers (
 397       FOLKS_PHONE_DETAILS (priv->individual));
 398
 399   sensitive = has_phone_account ();
 400
 401   iter = gee_iterable_iterator (GEE_ITERABLE (all_numbers));
 402   while (gee_iterator_next (iter))
 403     {
 404       FolksPhoneFieldDetails *details = gee_iterator_get (iter);
 405       GtkWidget *item, *image;
 406       gchar *tmp;
 407       const gchar *type;
 408
 409       type = find_phone_type (details);
 410
 411       if (type != NULL)
 412         {
 413           tmp = g_strdup_printf ("Call %s (%s)",
 414               folks_phone_field_details_get_normalised (details),
 415               type);
 416         }
 417       else
 418         {
 419           tmp = g_strdup_printf ("Call %s",
 420               folks_phone_field_details_get_normalised (details));
 421         }
 422
 423       item = gtk_image_menu_item_new_with_mnemonic (tmp);
 424       g_free (tmp);
 425
 426       g_signal_connect_data (item, "activate",
 427           G_CALLBACK (call_phone_number_cb), g_object_ref (details),
 428           (GClosureNotify) g_object_unref, 0);
 429
 430       gtk_widget_set_sensitive (item, sensitive);
 431
 432       image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CALL,
 433           GTK_ICON_SIZE_MENU);
 434       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 435       gtk_widget_show (image);
 436
 437       gtk_menu_shell_append (GTK_MENU_SHELL (self), item);
 438       gtk_widget_show (item);
 439     }
 440 }
 441
 442 static void
 443 constructed (GObject *object)
 444 {
 445   EmpathyIndividualMenu *self = (EmpathyIndividualMenu *) object;
 446   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
 447   GtkMenuShell *shell;
 448   GtkWidget *item;
 449   FolksIndividual *individual;
 450   EmpathyIndividualFeatureFlags features;
 451
 452   /* Build the menu */
 453   shell = GTK_MENU_SHELL (object);
 454   individual = priv->individual;
 455   features = priv->features;
 456
 457   /* Chat */
 458   if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
 459     {
 460       item = empathy_individual_chat_menu_item_new (individual, NULL);
 461       if (item != NULL)
 462         {
 463           gtk_menu_shell_append (shell, item);
 464           gtk_widget_show (item);
 465         }
 466     }
 467
 468   /* SMS */
 469   if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS)
 470     {
 471       item = empathy_individual_sms_menu_item_new (individual, NULL);
 472       if (item != NULL)
 473         {
 474           gtk_menu_shell_append (shell, item);
 475           gtk_widget_show (item);
 476         }
 477     }
 478
 479   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
 480     {
 481       /* Audio Call */
 482       item = empathy_individual_audio_call_menu_item_new (individual, NULL);
 483       gtk_menu_shell_append (shell, item);
 484       gtk_widget_show (item);
 485
 486       /* Video Call */
 487       item = empathy_individual_video_call_menu_item_new (individual, NULL);
 488       gtk_menu_shell_append (shell, item);
 489       gtk_widget_show (item);
 490     }
 491
 492   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL_PHONE)
 493     add_phone_numbers (self);
 494
 495   /* Invite */
 496   item = empathy_individual_invite_menu_item_new (individual, NULL);
 497   gtk_menu_shell_append (shell, item);
 498   gtk_widget_show (item);
 499
 500   /* File transfer */
 501   item = empathy_individual_file_transfer_menu_item_new (individual, NULL);
 502   gtk_menu_shell_append (shell, item);
 503   gtk_widget_show (item);
 504
 505   /* Share my desktop */
 506   /* FIXME we should add the "Share my desktop" menu item if Vino is
 507   a registered handler in MC5 */
 508   item = empathy_individual_share_my_desktop_menu_item_new (individual, NULL);
 509   gtk_menu_shell_append (shell, item);
 510   gtk_widget_show (item);
 511
 512   /* Menu items to target specific contacts */
 513   individual_menu_add_personas (GTK_MENU_SHELL (object), individual, features);
 514
 515   /* Separator */
 516   if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT |
 517       EMPATHY_INDIVIDUAL_FEATURE_INFO |
 518       EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE |
 519       EMPATHY_INDIVIDUAL_FEATURE_LINK))
 520     {
 521       item = gtk_separator_menu_item_new ();
 522       gtk_menu_shell_append (shell, item);
 523       gtk_widget_show (item);
 524     }
 525
 526   /* Edit */
 527   if (features & EMPATHY_INDIVIDUAL_FEATURE_EDIT)
 528     {
 529       item = empathy_individual_edit_menu_item_new (individual);
 530       gtk_menu_shell_append (shell, item);
 531       gtk_widget_show (item);
 532     }
 533
 534   /* Link */
 535   if (features & EMPATHY_INDIVIDUAL_FEATURE_LINK)
 536     {
 537       item = empathy_individual_link_menu_item_new (individual);
 538       gtk_menu_shell_append (shell, item);
 539
 540       g_signal_connect_swapped (item, "activate",
 541           (GCallback) individual_link_menu_item_activate_cb, object);
 542
 543       gtk_widget_show (item);
 544     }
 545
 546   /* Log */
 547   if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
 548     {
 549       item = empathy_individual_log_menu_item_new (individual, NULL);
 550       gtk_menu_shell_append (shell, item);
 551       gtk_widget_show (item);
 552     }
 553
 554   /* Info */
 555   if (features & EMPATHY_INDIVIDUAL_FEATURE_INFO)
 556     {
 557       item = empathy_individual_info_menu_item_new (individual);
 558       gtk_menu_shell_append (shell, item);
 559       gtk_widget_show (item);
 560     }
 561
 562   /* Favorite checkbox */
 563   if (features & EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE)
 564     {
 565       item = empathy_individual_favourite_menu_item_new (individual);
 566       gtk_menu_shell_append (shell, item);
 567       gtk_widget_show (item);
 568     }
 569 }
 570
 571 static void
 572 get_property (GObject *object,
 573     guint param_id,
 574     GValue *value,
 575     GParamSpec *pspec)
 576 {
 577   EmpathyIndividualMenuPriv *priv;
 578
 579   priv = GET_PRIV (object);
 580
 581   switch (param_id)
 582     {
 583       case PROP_INDIVIDUAL:
 584         g_value_set_object (value, priv->individual);
 585         break;
 586       case PROP_FEATURES:
 587         g_value_set_flags (value, priv->features);
 588         break;
 589       default:
 590         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 591         break;
 592     }
 593 }
 594
 595 static void
 596 set_property (GObject *object,
 597     guint param_id,
 598     const GValue *value,
 599     GParamSpec *pspec)
 600 {
 601   EmpathyIndividualMenuPriv *priv;
 602
 603   priv = GET_PRIV (object);
 604
 605   switch (param_id)
 606     {
 607       case PROP_INDIVIDUAL:
 608         priv->individual = g_value_dup_object (value);
 609         break;
 610       case PROP_FEATURES:
 611         priv->features = g_value_get_flags (value);
 612         break;
 613       default:
 614         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 615         break;
 616     }
 617 }
 618
 619 static void
 620 dispose (GObject *object)
 621 {
 622   EmpathyIndividualMenuPriv *priv = GET_PRIV (object);
 623
 624   tp_clear_object (&priv->individual);
 625
 626   G_OBJECT_CLASS (empathy_individual_menu_parent_class)->dispose (object);
 627 }
 628
 629 static void
 630 empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass)
 631 {
 632   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 633
 634   object_class->constructed = constructed;
 635   object_class->get_property = get_property;
 636   object_class->set_property = set_property;
 637   object_class->dispose = dispose;
 638
 639   /**
 640    * EmpathyIndividualMenu:individual:
 641    *
 642    * The #FolksIndividual the menu is for.
 643    */
 644   g_object_class_install_property (object_class, PROP_INDIVIDUAL,
 645       g_param_spec_object ("individual",
 646           "Individual",
 647           "The #FolksIndividual the menu is for.",
 648           FOLKS_TYPE_INDIVIDUAL,
 649           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
 650
 651   /**
 652    * EmpathyIndividualMenu:features:
 653    *
 654    * A set of feature flags controlling which entries are shown.
 655    */
 656   g_object_class_install_property (object_class, PROP_FEATURES,
 657       g_param_spec_flags ("features",
 658           "Features",
 659           "A set of feature flags controlling which entries are shown.",
 660           EMPATHY_TYPE_INDIVIDUAL_FEATURE_FLAGS,
 661           EMPATHY_INDIVIDUAL_FEATURE_NONE,
 662           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
 663
 664   signals[SIGNAL_LINK_CONTACTS_ACTIVATED] =
 665       g_signal_new ("link-contacts-activated", G_OBJECT_CLASS_TYPE (klass),
 666           G_SIGNAL_RUN_LAST, 0, NULL, NULL,
 667           g_cclosure_marshal_generic,
 668           G_TYPE_NONE, 1, EMPATHY_TYPE_LINKING_DIALOG);
 669
 670   g_type_class_add_private (object_class, sizeof (EmpathyIndividualMenuPriv));
 671 }
 672
 673 GtkWidget *
 674 empathy_individual_menu_new (FolksIndividual *individual,
 675     EmpathyIndividualFeatureFlags features)
 676 {
 677   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 678   g_return_val_if_fail (features != EMPATHY_INDIVIDUAL_FEATURE_NONE, NULL);
 679
 680   return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MENU,
 681       "individual", individual,
 682       "features", features,
 683       NULL);
 684 }
 685
 686 /* Like menu_item_set_first_contact(), but always operates upon the given
 687  * contact. If the contact is non-NULL, it is assumed that the menu entry should
 688  * be sensitive. */
 689 static gboolean
 690 menu_item_set_contact (GtkWidget *item,
 691     EmpathyContact *contact,
 692     GCallback activate_callback,
 693     EmpathyActionType action_type)
 694 {
 695   gboolean can_do_action = FALSE;
 696
 697   if (contact != NULL)
 698     can_do_action = empathy_contact_can_do_action (contact, action_type);
 699   gtk_widget_set_sensitive (item, can_do_action);
 700
 701   if (can_do_action == TRUE)
 702     {
 703       /* We want to make sure that the EmpathyContact stays alive while the
 704        * signal is connected. */
 705       g_signal_connect_data (item, "activate", G_CALLBACK (activate_callback),
 706           g_object_ref (contact), (GClosureNotify) g_object_unref, 0);
 707     }
 708
 709   return can_do_action;
 710 }
 711
 712 /**
 713  * Set the given menu @item to call @activate_callback using the TpContact
 714  * (associated with @individual) with the highest availability who is also valid
 715  * whenever @item is activated.
 716  *
 717  * @action_type is the type of action performed by the menu entry; this is used
 718  * so that only contacts which can perform that action (e.g. are capable of
 719  * receiving video calls) are selected, as appropriate.
 720  */
 721 static GtkWidget *
 722 menu_item_set_first_contact (GtkWidget *item,
 723     FolksIndividual *individual,
 724     GCallback activate_callback,
 725     EmpathyActionType action_type)
 726 {
 727   EmpathyContact *best_contact;
 728
 729   best_contact = empathy_contact_dup_best_for_action (individual, action_type);
 730   menu_item_set_contact (item, best_contact, G_CALLBACK (activate_callback),
 731       action_type);
 732   tp_clear_object (&best_contact);
 733
 734   return item;
 735 }
 736
 737 static void
 738 empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
 739   EmpathyContact *contact)
 740 {
 741   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 742
 743   empathy_chat_with_contact (contact, empathy_get_current_action_time ());
 744 }
 745
 746 GtkWidget *
 747 empathy_individual_chat_menu_item_new (FolksIndividual *individual,
 748     EmpathyContact *contact)
 749 {
 750   GtkWidget *item;
 751   GtkWidget *image;
 752
 753   g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) &&
 754       empathy_folks_individual_contains_contact (individual)) ||
 755       EMPATHY_IS_CONTACT (contact),
 756       NULL);
 757
 758   item = gtk_image_menu_item_new_with_mnemonic (_("_Chat"));
 759   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE,
 760       GTK_ICON_SIZE_MENU);
 761   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 762   gtk_widget_show (image);
 763
 764   if (contact != NULL)
 765     {
 766       menu_item_set_contact (item, contact,
 767           G_CALLBACK (empathy_individual_chat_menu_item_activated),
 768           EMPATHY_ACTION_CHAT);
 769     }
 770   else
 771     {
 772       menu_item_set_first_contact (item, individual,
 773           G_CALLBACK (empathy_individual_chat_menu_item_activated),
 774           EMPATHY_ACTION_CHAT);
 775     }
 776
 777   return item;
 778 }
 779
 780 static void
 781 empathy_individual_sms_menu_item_activated (GtkMenuItem *item,
 782   EmpathyContact *contact)
 783 {
 784   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 785
 786   empathy_sms_contact_id (
 787       empathy_contact_get_account (contact),
 788       empathy_contact_get_id (contact),
 789       empathy_get_current_action_time (),
 790       NULL, NULL);
 791 }
 792
 793 GtkWidget *
 794 empathy_individual_sms_menu_item_new (FolksIndividual *individual,
 795     EmpathyContact *contact)
 796 {
 797   GtkWidget *item;
 798   GtkWidget *image;
 799
 800   g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) &&
 801       empathy_folks_individual_contains_contact (individual)) ||
 802       EMPATHY_IS_CONTACT (contact),
 803       NULL);
 804
 805   item = gtk_image_menu_item_new_with_mnemonic (_("_SMS"));
 806   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS,
 807       GTK_ICON_SIZE_MENU);
 808   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 809   gtk_widget_show (image);
 810
 811   if (contact != NULL)
 812     {
 813       menu_item_set_contact (item, contact,
 814           G_CALLBACK (empathy_individual_sms_menu_item_activated),
 815           EMPATHY_ACTION_SMS);
 816     }
 817   else
 818     {
 819       menu_item_set_first_contact (item, individual,
 820           G_CALLBACK (empathy_individual_sms_menu_item_activated),
 821           EMPATHY_ACTION_SMS);
 822     }
 823
 824   return item;
 825 }
 826
 827 static void
 828 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
 829   EmpathyContact *contact)
 830 {
 831   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 832
 833   empathy_call_new_with_streams (empathy_contact_get_id (contact),
 834       empathy_contact_get_account (contact),
 835       TRUE, FALSE,
 836       empathy_get_current_action_time ());
 837 }
 838
 839 GtkWidget *
 840 empathy_individual_audio_call_menu_item_new (FolksIndividual *individual,
 841     EmpathyContact *contact)
 842 {
 843   GtkWidget *item;
 844   GtkWidget *image;
 845
 846   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 847       EMPATHY_IS_CONTACT (contact),
 848       NULL);
 849
 850   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
 851   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
 852   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 853   gtk_widget_show (image);
 854
 855   if (contact != NULL)
 856     {
 857       menu_item_set_contact (item, contact,
 858           G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
 859           EMPATHY_ACTION_AUDIO_CALL);
 860     }
 861   else
 862     {
 863       menu_item_set_first_contact (item, individual,
 864           G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
 865           EMPATHY_ACTION_AUDIO_CALL);
 866     }
 867
 868   return item;
 869 }
 870
 871 static void
 872 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
 873   EmpathyContact *contact)
 874 {
 875   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 876
 877   empathy_call_new_with_streams (empathy_contact_get_id (contact),
 878       empathy_contact_get_account (contact),
 879       TRUE, TRUE,
 880       empathy_get_current_action_time ());
 881 }
 882
 883 GtkWidget *
 884 empathy_individual_video_call_menu_item_new (FolksIndividual *individual,
 885     EmpathyContact *contact)
 886 {
 887   GtkWidget *item;
 888   GtkWidget *image;
 889   EmpathyCameraMonitor *monitor;
 890
 891   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 892       EMPATHY_IS_CONTACT (contact),
 893       NULL);
 894
 895   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
 896   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
 897       GTK_ICON_SIZE_MENU);
 898   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 899   gtk_widget_show (image);
 900
 901   if (contact != NULL)
 902     {
 903       menu_item_set_contact (item, contact,
 904           G_CALLBACK (empathy_individual_video_call_menu_item_activated),
 905           EMPATHY_ACTION_VIDEO_CALL);
 906     }
 907   else
 908     {
 909       menu_item_set_first_contact (item, individual,
 910           G_CALLBACK (empathy_individual_video_call_menu_item_activated),
 911           EMPATHY_ACTION_VIDEO_CALL);
 912     }
 913
 914   /* Only follow available cameras if the contact can do Video calls */
 915   if (gtk_widget_get_sensitive (item))
 916     {
 917       monitor = empathy_camera_monitor_dup_singleton ();
 918       g_object_set_data_full (G_OBJECT (item),
 919           "monitor", monitor, g_object_unref);
 920       g_object_bind_property (monitor, "available", item, "sensitive",
 921           G_BINDING_SYNC_CREATE);
 922     }
 923
 924   return item;
 925 }
 926
 927 static void
 928 empathy_individual_log_menu_item_activated (GtkMenuItem *item,
 929   EmpathyContact *contact)
 930 {
 931   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 932
 933   empathy_log_window_show (empathy_contact_get_account (contact),
 934       empathy_contact_get_id (contact), FALSE, NULL);
 935 }
 936
 937 GtkWidget *
 938 empathy_individual_log_menu_item_new (FolksIndividual *individual,
 939     EmpathyContact *contact)
 940 {
 941   GtkWidget *item;
 942   GtkWidget *image;
 943
 944   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 945       EMPATHY_IS_CONTACT (contact),
 946       NULL);
 947
 948   item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations"));
 949   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU);
 950   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 951   gtk_widget_show (image);
 952
 953   if (contact != NULL)
 954     {
 955       menu_item_set_contact (item, contact,
 956           G_CALLBACK (empathy_individual_log_menu_item_activated),
 957           EMPATHY_ACTION_VIEW_LOGS);
 958     }
 959   else
 960     {
 961       menu_item_set_first_contact (item, individual,
 962           G_CALLBACK (empathy_individual_log_menu_item_activated),
 963           EMPATHY_ACTION_VIEW_LOGS);
 964     }
 965
 966   return item;
 967 }
 968
 969 static void
 970 empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
 971     EmpathyContact *contact)
 972 {
 973   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 974
 975   empathy_send_file_with_file_chooser (contact);
 976 }
 977
 978 GtkWidget *
 979 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual,
 980     EmpathyContact *contact)
 981 {
 982   GtkWidget *item;
 983   GtkWidget *image;
 984
 985   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 986       EMPATHY_IS_CONTACT (contact),
 987       NULL);
 988
 989   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
 990   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
 991       GTK_ICON_SIZE_MENU);
 992   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 993   gtk_widget_show (image);
 994
 995   if (contact != NULL)
 996     {
 997       menu_item_set_contact (item, contact,
 998           G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
 999           EMPATHY_ACTION_SEND_FILE);
1000     }
1001   else
1002     {
1003       menu_item_set_first_contact (item, individual,
1004           G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
1005           EMPATHY_ACTION_SEND_FILE);
1006     }
1007
1008   return item;
1009 }
1010
1011 static void
1012 empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item,
1013     EmpathyContact *contact)
1014 {
1015   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1016
1017   empathy_share_my_desktop_share_with_contact (contact);
1018 }
1019
1020 GtkWidget *
1021 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual,
1022     EmpathyContact *contact)
1023 {
1024   GtkWidget *item;
1025   GtkWidget *image;
1026
1027   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1028       EMPATHY_IS_CONTACT (contact),
1029       NULL);
1030
1031   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
1032   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
1033   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1034   gtk_widget_show (image);
1035
1036   if (contact != NULL)
1037     {
1038       menu_item_set_contact (item, contact,
1039           G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1040           EMPATHY_ACTION_SHARE_MY_DESKTOP);
1041     }
1042   else
1043     {
1044       menu_item_set_first_contact (item, individual,
1045           G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1046           EMPATHY_ACTION_SHARE_MY_DESKTOP);
1047     }
1048
1049   return item;
1050 }
1051
1052 static void
1053 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
1054   FolksIndividual *individual)
1055 {
1056   folks_favourite_details_set_is_favourite (
1057       FOLKS_FAVOURITE_DETAILS (individual),
1058       gtk_check_menu_item_get_active (item));
1059 }
1060
1061 GtkWidget *
1062 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
1063 {
1064   GtkWidget *item;
1065
1066   item = gtk_check_menu_item_new_with_label (_("Favorite"));
1067
1068   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
1069       folks_favourite_details_get_is_favourite (
1070           FOLKS_FAVOURITE_DETAILS (individual)));
1071
1072   g_signal_connect (item, "toggled",
1073       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
1074
1075   return item;
1076 }
1077
1078 static void
1079 individual_info_menu_item_activate_cb (FolksIndividual *individual)
1080 {
1081   empathy_individual_information_dialog_show (individual, NULL);
1082 }
1083
1084 GtkWidget *
1085 empathy_individual_info_menu_item_new (FolksIndividual *individual)
1086 {
1087   GtkWidget *item;
1088   GtkWidget *image;
1089
1090   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1091   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
1092       NULL);
1093
1094   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
1095   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
1096                 GTK_ICON_SIZE_MENU);
1097   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1098   gtk_widget_show (image);
1099
1100   g_signal_connect_swapped (item, "activate",
1101           G_CALLBACK (individual_info_menu_item_activate_cb),
1102           individual);
1103
1104   return item;
1105 }
1106
1107 static void
1108 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
1109 {
1110   empathy_individual_edit_dialog_show (individual, NULL);
1111 }
1112
1113 GtkWidget *
1114 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
1115 {
1116   EmpathyIndividualManager *manager;
1117   GtkWidget *item;
1118   GtkWidget *image;
1119   gboolean enable = FALSE;
1120   EmpathyContact *contact;
1121
1122   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1123
1124   contact = empathy_contact_dup_from_folks_individual (individual);
1125
1126   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
1127
1128   if (empathy_individual_manager_initialized ())
1129     {
1130       TpConnection *connection;
1131
1132       manager = empathy_individual_manager_dup_singleton ();
1133       connection = empathy_contact_get_connection (contact);
1134
1135       enable = (empathy_connection_can_alias_personas (connection,
1136                                                        individual) &&
1137                 empathy_connection_can_group_personas (connection, individual));
1138
1139       g_object_unref (manager);
1140     }
1141
1142   item = gtk_image_menu_item_new_with_mnemonic (
1143       C_("Edit individual (contextual menu)", "_Edit"));
1144   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1145   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1146   gtk_widget_show (image);
1147
1148   gtk_widget_set_sensitive (item, enable);
1149
1150   g_signal_connect_swapped (item, "activate",
1151       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
1152
1153   g_object_unref (contact);
1154
1155   return item;
1156 }
1157
1158 GtkWidget *
1159 empathy_individual_link_menu_item_new (FolksIndividual *individual)
1160 {
1161   GtkWidget *item;
1162   /*GtkWidget *image;*/
1163
1164   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1165
1166   item = gtk_image_menu_item_new_with_mnemonic (
1167       /* Translators: this is a verb meaning "to connect two contacts together
1168        * to form a meta-contact". */
1169       C_("Link individual (contextual menu)", "_Link Contacts…"));
1170   /* TODO */
1171   /*image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1172   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1173   gtk_widget_show (image);*/
1174
1175   /* Only allow trusted Individuals to be linked */
1176   gtk_widget_set_sensitive (item,
1177       folks_individual_get_trust_level (individual) ==
1178           FOLKS_TRUST_LEVEL_PERSONAS);
1179
1180   return item;
1181 }
1182
1183 typedef struct
1184 {
1185   FolksIndividual *individual;
1186   EmpathyContact *contact;
1187   EmpathyChatroom *chatroom;
1188 } RoomSubMenuData;
1189
1190 static RoomSubMenuData *
1191 room_sub_menu_data_new (FolksIndividual *individual,
1192     EmpathyContact *contact,
1193     EmpathyChatroom *chatroom)
1194 {
1195   RoomSubMenuData *data;
1196
1197   data = g_slice_new0 (RoomSubMenuData);
1198   if (individual != NULL)
1199     data->individual = g_object_ref (individual);
1200   if (contact != NULL)
1201     data->contact = g_object_ref (contact);
1202   data->chatroom = g_object_ref (chatroom);
1203
1204   return data;
1205 }
1206
1207 static void
1208 room_sub_menu_data_free (RoomSubMenuData *data)
1209 {
1210   tp_clear_object (&data->individual);
1211   tp_clear_object (&data->contact);
1212   g_object_unref (data->chatroom);
1213   g_slice_free (RoomSubMenuData, data);
1214 }
1215
1216 static void
1217 room_sub_menu_activate_cb (GtkWidget *item,
1218          RoomSubMenuData *data)
1219 {
1220   EmpathyTpChat *chat;
1221   EmpathyChatroomManager *mgr;
1222   EmpathyContact *contact = NULL;
1223
1224   chat = empathy_chatroom_get_tp_chat (data->chatroom);
1225   if (chat == NULL)
1226     {
1227       /* channel was invalidated. Ignoring */
1228       return;
1229     }
1230
1231   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1232
1233   if (data->contact != NULL)
1234     contact = g_object_ref (data->contact);
1235   else
1236     {
1237       GeeSet *personas;
1238       GeeIterator *iter;
1239
1240       /* find the first of this Individual's contacts who can join this room */
1241       personas = folks_individual_get_personas (data->individual);
1242
1243       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1244       while (gee_iterator_next (iter) && (contact == NULL))
1245         {
1246           TpfPersona *persona = gee_iterator_get (iter);
1247           TpContact *tp_contact;
1248           GList *rooms;
1249
1250           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1251             {
1252               tp_contact = tpf_persona_get_contact (persona);
1253               if (tp_contact != NULL)
1254                 {
1255                   contact = empathy_contact_dup_from_tp_contact (tp_contact);
1256
1257                   rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1258                       empathy_contact_get_account (contact));
1259
1260                   if (g_list_find (rooms, data->chatroom) == NULL)
1261                     g_clear_object (&contact);
1262
1263                   /* if contact != NULL here, we've found our match */
1264
1265                   g_list_free (rooms);
1266                 }
1267             }
1268           g_clear_object (&persona);
1269         }
1270       g_clear_object (&iter);
1271     }
1272
1273   g_object_unref (mgr);
1274
1275   if (contact == NULL)
1276     {
1277       /* contact disappeared. Ignoring */
1278       goto out;
1279     }
1280
1281   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1282
1283   /* send invitation */
1284   empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat),
1285       contact, _("Inviting you to this room"));
1286
1287 out:
1288   g_object_unref (contact);
1289 }
1290
1291 static GtkWidget *
1292 create_room_sub_menu (FolksIndividual *individual,
1293                       EmpathyContact *contact,
1294                       EmpathyChatroom *chatroom)
1295 {
1296   GtkWidget *item;
1297   RoomSubMenuData *data;
1298
1299   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
1300   data = room_sub_menu_data_new (individual, contact, chatroom);
1301   g_signal_connect_data (item, "activate",
1302       G_CALLBACK (room_sub_menu_activate_cb), data,
1303       (GClosureNotify) room_sub_menu_data_free, 0);
1304
1305   return item;
1306 }
1307
1308 GtkWidget *
1309 empathy_individual_invite_menu_item_new (FolksIndividual *individual,
1310     EmpathyContact *contact)
1311 {
1312   GtkWidget *item;
1313   GtkWidget *image;
1314   GtkWidget *room_item;
1315   EmpathyChatroomManager *mgr;
1316   GList *rooms = NULL;
1317   GList *names = NULL;
1318   GList *l;
1319   GtkWidget *submenu = NULL;
1320   /* map of chat room names to their objects; just a utility to remove
1321    * duplicates and to make construction of the alphabetized list easier */
1322   GHashTable *name_room_map;
1323
1324   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1325       EMPATHY_IS_CONTACT (contact),
1326       NULL);
1327
1328   name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
1329       g_object_unref);
1330
1331   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
1332   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
1333       GTK_ICON_SIZE_MENU);
1334   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1335
1336   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1337
1338   if (contact != NULL)
1339     {
1340       rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1341           empathy_contact_get_account (contact));
1342     }
1343   else
1344     {
1345       GeeSet *personas;
1346       GeeIterator *iter;
1347
1348       /* find the first of this Individual's contacts who can join this room */
1349       personas = folks_individual_get_personas (individual);
1350       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1351       while (gee_iterator_next (iter))
1352         {
1353           TpfPersona *persona = gee_iterator_get (iter);
1354           GList *rooms_cur;
1355           TpContact *tp_contact;
1356           EmpathyContact *contact_cur;
1357
1358           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1359             {
1360               tp_contact = tpf_persona_get_contact (persona);
1361               if (tp_contact != NULL)
1362                 {
1363                   contact_cur = empathy_contact_dup_from_tp_contact (
1364                       tp_contact);
1365
1366                   rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
1367                       empathy_contact_get_account (contact_cur));
1368                   rooms = g_list_concat (rooms, rooms_cur);
1369
1370                   g_object_unref (contact_cur);
1371                 }
1372             }
1373           g_clear_object (&persona);
1374         }
1375       g_clear_object (&iter);
1376     }
1377
1378   /* alphabetize the rooms */
1379   for (l = rooms; l != NULL; l = g_list_next (l))
1380     {
1381       EmpathyChatroom *chatroom = l->data;
1382       gboolean existed;
1383
1384       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
1385         {
1386           const gchar *name;
1387
1388           name = empathy_chatroom_get_name (chatroom);
1389           existed = (g_hash_table_lookup (name_room_map, name) != NULL);
1390           g_hash_table_insert (name_room_map, (gpointer) name,
1391               g_object_ref (chatroom));
1392
1393           /* this will take care of duplicates in rooms */
1394           if (!existed)
1395             {
1396               names = g_list_insert_sorted (names, (gpointer) name,
1397                   (GCompareFunc) g_strcmp0);
1398             }
1399         }
1400     }
1401
1402   for (l = names; l != NULL; l = g_list_next (l))
1403     {
1404       const gchar *name = l->data;
1405       EmpathyChatroom *chatroom;
1406
1407       if (G_UNLIKELY (submenu == NULL))
1408         submenu = gtk_menu_new ();
1409
1410       chatroom = g_hash_table_lookup (name_room_map, name);
1411       room_item = create_room_sub_menu (individual, contact, chatroom);
1412       gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
1413       gtk_widget_show (room_item);
1414     }
1415
1416   if (submenu)
1417     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
1418   else
1419     gtk_widget_set_sensitive (item, FALSE);
1420
1421   gtk_widget_show (image);
1422
1423   g_hash_table_destroy (name_room_map);
1424   g_object_unref (mgr);
1425   g_list_free (names);
1426   g_list_free (rooms);
1427
1428   return item;
1429 }