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_VOID__OBJECT,
 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 }
 791
 792 GtkWidget *
 793 empathy_individual_sms_menu_item_new (FolksIndividual *individual,
 794     EmpathyContact *contact)
 795 {
 796   GtkWidget *item;
 797   GtkWidget *image;
 798
 799   g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) &&
 800       empathy_folks_individual_contains_contact (individual)) ||
 801       EMPATHY_IS_CONTACT (contact),
 802       NULL);
 803
 804   item = gtk_image_menu_item_new_with_mnemonic (_("_SMS"));
 805   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS,
 806       GTK_ICON_SIZE_MENU);
 807   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 808   gtk_widget_show (image);
 809
 810   if (contact != NULL)
 811     {
 812       menu_item_set_contact (item, contact,
 813           G_CALLBACK (empathy_individual_sms_menu_item_activated),
 814           EMPATHY_ACTION_SMS);
 815     }
 816   else
 817     {
 818       menu_item_set_first_contact (item, individual,
 819           G_CALLBACK (empathy_individual_sms_menu_item_activated),
 820           EMPATHY_ACTION_SMS);
 821     }
 822
 823   return item;
 824 }
 825
 826 static void
 827 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
 828   EmpathyContact *contact)
 829 {
 830   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 831
 832   empathy_call_new_with_streams (empathy_contact_get_id (contact),
 833       empathy_contact_get_account (contact),
 834       TRUE, FALSE,
 835       empathy_get_current_action_time ());
 836 }
 837
 838 GtkWidget *
 839 empathy_individual_audio_call_menu_item_new (FolksIndividual *individual,
 840     EmpathyContact *contact)
 841 {
 842   GtkWidget *item;
 843   GtkWidget *image;
 844
 845   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 846       EMPATHY_IS_CONTACT (contact),
 847       NULL);
 848
 849   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
 850   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
 851   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 852   gtk_widget_show (image);
 853
 854   if (contact != NULL)
 855     {
 856       menu_item_set_contact (item, contact,
 857           G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
 858           EMPATHY_ACTION_AUDIO_CALL);
 859     }
 860   else
 861     {
 862       menu_item_set_first_contact (item, individual,
 863           G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
 864           EMPATHY_ACTION_AUDIO_CALL);
 865     }
 866
 867   return item;
 868 }
 869
 870 static void
 871 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
 872   EmpathyContact *contact)
 873 {
 874   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 875
 876   empathy_call_new_with_streams (empathy_contact_get_id (contact),
 877       empathy_contact_get_account (contact),
 878       TRUE, TRUE,
 879       empathy_get_current_action_time ());
 880 }
 881
 882 GtkWidget *
 883 empathy_individual_video_call_menu_item_new (FolksIndividual *individual,
 884     EmpathyContact *contact)
 885 {
 886   GtkWidget *item;
 887   GtkWidget *image;
 888   EmpathyCameraMonitor *monitor;
 889
 890   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 891       EMPATHY_IS_CONTACT (contact),
 892       NULL);
 893
 894   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
 895   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
 896       GTK_ICON_SIZE_MENU);
 897   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 898   gtk_widget_show (image);
 899
 900   if (contact != NULL)
 901     {
 902       menu_item_set_contact (item, contact,
 903           G_CALLBACK (empathy_individual_video_call_menu_item_activated),
 904           EMPATHY_ACTION_VIDEO_CALL);
 905     }
 906   else
 907     {
 908       menu_item_set_first_contact (item, individual,
 909           G_CALLBACK (empathy_individual_video_call_menu_item_activated),
 910           EMPATHY_ACTION_VIDEO_CALL);
 911     }
 912
 913   /* Only follow available cameras if the contact can do Video calls */
 914   if (gtk_widget_get_sensitive (item))
 915     {
 916       monitor = empathy_camera_monitor_dup_singleton ();
 917       g_object_set_data_full (G_OBJECT (item),
 918           "monitor", monitor, g_object_unref);
 919       g_object_bind_property (monitor, "available", item, "sensitive",
 920           G_BINDING_SYNC_CREATE);
 921     }
 922
 923   return item;
 924 }
 925
 926 static void
 927 empathy_individual_log_menu_item_activated (GtkMenuItem *item,
 928   EmpathyContact *contact)
 929 {
 930   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 931
 932   empathy_log_window_show (empathy_contact_get_account (contact),
 933       empathy_contact_get_id (contact), FALSE, NULL);
 934 }
 935
 936 GtkWidget *
 937 empathy_individual_log_menu_item_new (FolksIndividual *individual,
 938     EmpathyContact *contact)
 939 {
 940   GtkWidget *item;
 941   GtkWidget *image;
 942
 943   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 944       EMPATHY_IS_CONTACT (contact),
 945       NULL);
 946
 947   item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations"));
 948   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU);
 949   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 950   gtk_widget_show (image);
 951
 952   if (contact != NULL)
 953     {
 954       menu_item_set_contact (item, contact,
 955           G_CALLBACK (empathy_individual_log_menu_item_activated),
 956           EMPATHY_ACTION_VIEW_LOGS);
 957     }
 958   else
 959     {
 960       menu_item_set_first_contact (item, individual,
 961           G_CALLBACK (empathy_individual_log_menu_item_activated),
 962           EMPATHY_ACTION_VIEW_LOGS);
 963     }
 964
 965   return item;
 966 }
 967
 968 static void
 969 empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
 970     EmpathyContact *contact)
 971 {
 972   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 973
 974   empathy_send_file_with_file_chooser (contact);
 975 }
 976
 977 GtkWidget *
 978 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual,
 979     EmpathyContact *contact)
 980 {
 981   GtkWidget *item;
 982   GtkWidget *image;
 983
 984   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
 985       EMPATHY_IS_CONTACT (contact),
 986       NULL);
 987
 988   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
 989   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
 990       GTK_ICON_SIZE_MENU);
 991   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 992   gtk_widget_show (image);
 993
 994   if (contact != NULL)
 995     {
 996       menu_item_set_contact (item, contact,
 997           G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
 998           EMPATHY_ACTION_SEND_FILE);
 999     }
1000   else
1001     {
1002       menu_item_set_first_contact (item, individual,
1003           G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
1004           EMPATHY_ACTION_SEND_FILE);
1005     }
1006
1007   return item;
1008 }
1009
1010 static void
1011 empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item,
1012     EmpathyContact *contact)
1013 {
1014   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1015
1016   empathy_share_my_desktop_share_with_contact (contact);
1017 }
1018
1019 GtkWidget *
1020 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual,
1021     EmpathyContact *contact)
1022 {
1023   GtkWidget *item;
1024   GtkWidget *image;
1025
1026   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1027       EMPATHY_IS_CONTACT (contact),
1028       NULL);
1029
1030   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
1031   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
1032   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1033   gtk_widget_show (image);
1034
1035   if (contact != NULL)
1036     {
1037       menu_item_set_contact (item, contact,
1038           G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1039           EMPATHY_ACTION_SHARE_MY_DESKTOP);
1040     }
1041   else
1042     {
1043       menu_item_set_first_contact (item, individual,
1044           G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
1045           EMPATHY_ACTION_SHARE_MY_DESKTOP);
1046     }
1047
1048   return item;
1049 }
1050
1051 static void
1052 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
1053   FolksIndividual *individual)
1054 {
1055   folks_favourite_details_set_is_favourite (
1056       FOLKS_FAVOURITE_DETAILS (individual),
1057       gtk_check_menu_item_get_active (item));
1058 }
1059
1060 GtkWidget *
1061 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
1062 {
1063   GtkWidget *item;
1064
1065   item = gtk_check_menu_item_new_with_label (_("Favorite"));
1066
1067   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
1068       folks_favourite_details_get_is_favourite (
1069           FOLKS_FAVOURITE_DETAILS (individual)));
1070
1071   g_signal_connect (item, "toggled",
1072       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
1073
1074   return item;
1075 }
1076
1077 static void
1078 individual_info_menu_item_activate_cb (FolksIndividual *individual)
1079 {
1080   empathy_individual_information_dialog_show (individual, NULL);
1081 }
1082
1083 GtkWidget *
1084 empathy_individual_info_menu_item_new (FolksIndividual *individual)
1085 {
1086   GtkWidget *item;
1087   GtkWidget *image;
1088
1089   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1090   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
1091       NULL);
1092
1093   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
1094   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
1095                 GTK_ICON_SIZE_MENU);
1096   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1097   gtk_widget_show (image);
1098
1099   g_signal_connect_swapped (item, "activate",
1100           G_CALLBACK (individual_info_menu_item_activate_cb),
1101           individual);
1102
1103   return item;
1104 }
1105
1106 static void
1107 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
1108 {
1109   empathy_individual_edit_dialog_show (individual, NULL);
1110 }
1111
1112 GtkWidget *
1113 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
1114 {
1115   EmpathyIndividualManager *manager;
1116   GtkWidget *item;
1117   GtkWidget *image;
1118   gboolean enable = FALSE;
1119   EmpathyContact *contact;
1120
1121   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1122
1123   contact = empathy_contact_dup_from_folks_individual (individual);
1124
1125   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
1126
1127   if (empathy_individual_manager_initialized ())
1128     {
1129       TpConnection *connection;
1130
1131       manager = empathy_individual_manager_dup_singleton ();
1132       connection = empathy_contact_get_connection (contact);
1133
1134       enable = (empathy_connection_can_alias_personas (connection,
1135                                                        individual) &&
1136                 empathy_connection_can_group_personas (connection, individual));
1137
1138       g_object_unref (manager);
1139     }
1140
1141   item = gtk_image_menu_item_new_with_mnemonic (
1142       C_("Edit individual (contextual menu)", "_Edit"));
1143   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1144   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1145   gtk_widget_show (image);
1146
1147   gtk_widget_set_sensitive (item, enable);
1148
1149   g_signal_connect_swapped (item, "activate",
1150       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
1151
1152   g_object_unref (contact);
1153
1154   return item;
1155 }
1156
1157 GtkWidget *
1158 empathy_individual_link_menu_item_new (FolksIndividual *individual)
1159 {
1160   GtkWidget *item;
1161   /*GtkWidget *image;*/
1162
1163   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
1164
1165   item = gtk_image_menu_item_new_with_mnemonic (
1166       /* Translators: this is a verb meaning "to connect two contacts together
1167        * to form a meta-contact". */
1168       C_("Link individual (contextual menu)", "_Link Contacts…"));
1169   /* TODO */
1170   /*image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
1171   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1172   gtk_widget_show (image);*/
1173
1174   /* Only allow trusted Individuals to be linked */
1175   gtk_widget_set_sensitive (item,
1176       folks_individual_get_trust_level (individual) ==
1177           FOLKS_TRUST_LEVEL_PERSONAS);
1178
1179   return item;
1180 }
1181
1182 typedef struct
1183 {
1184   FolksIndividual *individual;
1185   EmpathyContact *contact;
1186   EmpathyChatroom *chatroom;
1187 } RoomSubMenuData;
1188
1189 static RoomSubMenuData *
1190 room_sub_menu_data_new (FolksIndividual *individual,
1191     EmpathyContact *contact,
1192     EmpathyChatroom *chatroom)
1193 {
1194   RoomSubMenuData *data;
1195
1196   data = g_slice_new0 (RoomSubMenuData);
1197   if (individual != NULL)
1198     data->individual = g_object_ref (individual);
1199   if (contact != NULL)
1200     data->contact = g_object_ref (contact);
1201   data->chatroom = g_object_ref (chatroom);
1202
1203   return data;
1204 }
1205
1206 static void
1207 room_sub_menu_data_free (RoomSubMenuData *data)
1208 {
1209   tp_clear_object (&data->individual);
1210   tp_clear_object (&data->contact);
1211   g_object_unref (data->chatroom);
1212   g_slice_free (RoomSubMenuData, data);
1213 }
1214
1215 static void
1216 room_sub_menu_activate_cb (GtkWidget *item,
1217          RoomSubMenuData *data)
1218 {
1219   EmpathyTpChat *chat;
1220   EmpathyChatroomManager *mgr;
1221   EmpathyContact *contact = NULL;
1222
1223   chat = empathy_chatroom_get_tp_chat (data->chatroom);
1224   if (chat == NULL)
1225     {
1226       /* channel was invalidated. Ignoring */
1227       return;
1228     }
1229
1230   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1231
1232   if (data->contact != NULL)
1233     contact = g_object_ref (data->contact);
1234   else
1235     {
1236       GeeSet *personas;
1237       GeeIterator *iter;
1238
1239       /* find the first of this Individual's contacts who can join this room */
1240       personas = folks_individual_get_personas (data->individual);
1241
1242       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1243       while (gee_iterator_next (iter) && (contact == NULL))
1244         {
1245           TpfPersona *persona = gee_iterator_get (iter);
1246           TpContact *tp_contact;
1247           GList *rooms;
1248
1249           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1250             {
1251               tp_contact = tpf_persona_get_contact (persona);
1252               if (tp_contact != NULL)
1253                 {
1254                   contact = empathy_contact_dup_from_tp_contact (tp_contact);
1255
1256                   rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1257                       empathy_contact_get_account (contact));
1258
1259                   if (g_list_find (rooms, data->chatroom) == NULL)
1260                     g_clear_object (&contact);
1261
1262                   /* if contact != NULL here, we've found our match */
1263
1264                   g_list_free (rooms);
1265                 }
1266             }
1267           g_clear_object (&persona);
1268         }
1269       g_clear_object (&iter);
1270     }
1271
1272   g_object_unref (mgr);
1273
1274   if (contact == NULL)
1275     {
1276       /* contact disappeared. Ignoring */
1277       goto out;
1278     }
1279
1280   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
1281
1282   /* send invitation */
1283   empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat),
1284       contact, _("Inviting you to this room"));
1285
1286 out:
1287   g_object_unref (contact);
1288 }
1289
1290 static GtkWidget *
1291 create_room_sub_menu (FolksIndividual *individual,
1292                       EmpathyContact *contact,
1293                       EmpathyChatroom *chatroom)
1294 {
1295   GtkWidget *item;
1296   RoomSubMenuData *data;
1297
1298   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
1299   data = room_sub_menu_data_new (individual, contact, chatroom);
1300   g_signal_connect_data (item, "activate",
1301       G_CALLBACK (room_sub_menu_activate_cb), data,
1302       (GClosureNotify) room_sub_menu_data_free, 0);
1303
1304   return item;
1305 }
1306
1307 GtkWidget *
1308 empathy_individual_invite_menu_item_new (FolksIndividual *individual,
1309     EmpathyContact *contact)
1310 {
1311   GtkWidget *item;
1312   GtkWidget *image;
1313   GtkWidget *room_item;
1314   EmpathyChatroomManager *mgr;
1315   GList *rooms = NULL;
1316   GList *names = NULL;
1317   GList *l;
1318   GtkWidget *submenu = NULL;
1319   /* map of chat room names to their objects; just a utility to remove
1320    * duplicates and to make construction of the alphabetized list easier */
1321   GHashTable *name_room_map;
1322
1323   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
1324       EMPATHY_IS_CONTACT (contact),
1325       NULL);
1326
1327   name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
1328       g_object_unref);
1329
1330   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
1331   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
1332       GTK_ICON_SIZE_MENU);
1333   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1334
1335   mgr = empathy_chatroom_manager_dup_singleton (NULL);
1336
1337   if (contact != NULL)
1338     {
1339       rooms = empathy_chatroom_manager_get_chatrooms (mgr,
1340           empathy_contact_get_account (contact));
1341     }
1342   else
1343     {
1344       GeeSet *personas;
1345       GeeIterator *iter;
1346
1347       /* find the first of this Individual's contacts who can join this room */
1348       personas = folks_individual_get_personas (individual);
1349       iter = gee_iterable_iterator (GEE_ITERABLE (personas));
1350       while (gee_iterator_next (iter))
1351         {
1352           TpfPersona *persona = gee_iterator_get (iter);
1353           GList *rooms_cur;
1354           TpContact *tp_contact;
1355           EmpathyContact *contact_cur;
1356
1357           if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
1358             {
1359               tp_contact = tpf_persona_get_contact (persona);
1360               if (tp_contact != NULL)
1361                 {
1362                   contact_cur = empathy_contact_dup_from_tp_contact (
1363                       tp_contact);
1364
1365                   rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
1366                       empathy_contact_get_account (contact_cur));
1367                   rooms = g_list_concat (rooms, rooms_cur);
1368
1369                   g_object_unref (contact_cur);
1370                 }
1371             }
1372           g_clear_object (&persona);
1373         }
1374       g_clear_object (&iter);
1375     }
1376
1377   /* alphabetize the rooms */
1378   for (l = rooms; l != NULL; l = g_list_next (l))
1379     {
1380       EmpathyChatroom *chatroom = l->data;
1381       gboolean existed;
1382
1383       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
1384         {
1385           const gchar *name;
1386
1387           name = empathy_chatroom_get_name (chatroom);
1388           existed = (g_hash_table_lookup (name_room_map, name) != NULL);
1389           g_hash_table_insert (name_room_map, (gpointer) name,
1390               g_object_ref (chatroom));
1391
1392           /* this will take care of duplicates in rooms */
1393           if (!existed)
1394             {
1395               names = g_list_insert_sorted (names, (gpointer) name,
1396                   (GCompareFunc) g_strcmp0);
1397             }
1398         }
1399     }
1400
1401   for (l = names; l != NULL; l = g_list_next (l))
1402     {
1403       const gchar *name = l->data;
1404       EmpathyChatroom *chatroom;
1405
1406       if (G_UNLIKELY (submenu == NULL))
1407         submenu = gtk_menu_new ();
1408
1409       chatroom = g_hash_table_lookup (name_room_map, name);
1410       room_item = create_room_sub_menu (individual, contact, chatroom);
1411       gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
1412       gtk_widget_show (room_item);
1413     }
1414
1415   if (submenu)
1416     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
1417   else
1418     gtk_widget_set_sensitive (item, FALSE);
1419
1420   gtk_widget_show (image);
1421
1422   g_hash_table_destroy (name_room_map);
1423   g_object_unref (mgr);
1424   g_list_free (names);
1425   g_list_free (rooms);
1426
1427   return item;
1428 }