diff --git a/libempathy-gtk/empathy-individual-dialogs.c b/libempathy-gtk/empathy-individual-dialogs.c
index cd5c0f3..1e5b23d 100644
--- a/libempathy-gtk/empathy-individual-dialogs.c
+++ b/libempathy-gtk/empathy-individual-dialogs.c
@@ -29,6 +29,7 @@
 
 #include <telepathy-glib/util.h>
 #include <folks/folks.h>
+#include <folks/folks-telepathy.h>
 
 #include <libempathy/empathy-individual-manager.h>
 #include <libempathy/empathy-utils.h>
@@ -37,8 +38,99 @@
 #include "empathy-contact-widget.h"
 #include "empathy-ui-utils.h"
 
+static GList *information_dialogs = NULL;
 static GtkWidget *new_individual_dialog = NULL;
 
+static void
+individual_dialogs_response_cb (GtkDialog *dialog, gint response, GList **dialogs)
+{
+  *dialogs = g_list_remove (*dialogs, dialog);
+  gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
+static gint
+individual_dialogs_find (GtkDialog *dialog, FolksIndividual *individual)
+{
+  return individual != g_object_get_data (G_OBJECT (dialog), "individual");
+}
+
+/*
+ *  Information dialog
+ */
+
+void
+empathy_individual_information_dialog_show (FolksIndividual *individual,
+    GtkWindow *parent)
+{
+  GtkWidget *dialog;
+  GtkWidget *button;
+  GList *personas, *l;
+
+  g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
+
+  l = g_list_find_custom (information_dialogs, individual,
+      (GCompareFunc) individual_dialogs_find);
+  if (l)
+    {
+      gtk_window_present (GTK_WINDOW (l->data));
+      return;
+    }
+
+  /* Create dialog */
+  dialog = gtk_dialog_new ();
+  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+  gtk_window_set_title (GTK_WINDOW (dialog),
+      folks_individual_get_alias (individual));
+
+  /* Close button */
+  button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
+  gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
+  gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
+      GTK_RESPONSE_CLOSE);
+  gtk_widget_set_can_default (button, TRUE);
+  gtk_window_set_default (GTK_WINDOW (dialog), button);
+  gtk_widget_show (button);
+
+  personas = folks_individual_get_personas (individual);
+
+  for (l = personas; l != NULL; l = l->next)
+    {
+      GtkWidget *contact_widget;
+      TpContact *tp_contact;
+      EmpathyContact *contact;
+      TpfPersona *persona = l->data;
+
+      if (!TPF_IS_PERSONA (persona))
+        continue;
+
+      tp_contact = tpf_persona_get_contact (persona);
+      contact = empathy_contact_dup_from_tp_contact (tp_contact);
+
+      /* Contact info widget */
+      contact_widget = empathy_contact_widget_new (contact,
+          EMPATHY_CONTACT_WIDGET_SHOW_LOCATION |
+          EMPATHY_CONTACT_WIDGET_SHOW_DETAILS);
+      gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
+      gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (
+          GTK_DIALOG (dialog))), contact_widget, TRUE, TRUE, 0);
+      gtk_widget_show (contact_widget);
+
+      g_object_unref (contact);
+    }
+
+  g_object_set_data (G_OBJECT (dialog), "individual", individual);
+  information_dialogs = g_list_prepend (information_dialogs, dialog);
+
+  g_signal_connect (dialog, "response",
+      G_CALLBACK (individual_dialogs_response_cb), &information_dialogs);
+
+  if (parent)
+    gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
+
+  gtk_widget_show (dialog);
+}
+
 /*
  *  New contact dialog
  */
diff --git a/libempathy-gtk/empathy-individual-dialogs.h b/libempathy-gtk/empathy-individual-dialogs.h
index b34a7ab..9d4ac59 100644
--- a/libempathy-gtk/empathy-individual-dialogs.h
+++ b/libempathy-gtk/empathy-individual-dialogs.h
@@ -29,6 +29,9 @@
 
 G_BEGIN_DECLS
 
+void empathy_individual_information_dialog_show (FolksIndividual *individual,
+    GtkWindow *parent);
+
 void empathy_new_individual_dialog_show (GtkWindow *parent);
 void empathy_new_individual_dialog_show_with_individual (GtkWindow *parent,
     FolksIndividual *individual);
diff --git a/libempathy-gtk/empathy-individual-menu.c b/libempathy-gtk/empathy-individual-menu.c
index 4e62530..23520a6 100644
--- a/libempathy-gtk/empathy-individual-menu.c
+++ b/libempathy-gtk/empathy-individual-menu.c
@@ -28,6 +28,8 @@
 #include <gtk/gtk.h>
 #include <telepathy-glib/util.h>
 #include <telepathy-logger/log-manager.h>
+#include <folks/folks.h>
+#include <folks/folks-telepathy.h>
 
 #include <libempathy/empathy-call-factory.h>
 #include <libempathy/empathy-dispatcher.h>
@@ -72,7 +74,7 @@ empathy_individual_menu_new (FolksIndividual *individual,
   /* Chat */
   if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
     {
-      item = empathy_individual_chat_menu_item_new (individual);
+      item = empathy_individual_chat_menu_item_new (individual, NULL);
       if (item != NULL)
         {
           gtk_menu_shell_append (shell, item);
@@ -83,12 +85,12 @@ empathy_individual_menu_new (FolksIndividual *individual,
   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
     {
       /* Audio Call */
-      item = empathy_individual_audio_call_menu_item_new (individual);
+      item = empathy_individual_audio_call_menu_item_new (individual, NULL);
       gtk_menu_shell_append (shell, item);
       gtk_widget_show (item);
 
       /* Video Call */
-      item = empathy_individual_video_call_menu_item_new (individual);
+      item = empathy_individual_video_call_menu_item_new (individual, NULL);
       gtk_menu_shell_append (shell, item);
       gtk_widget_show (item);
     }
@@ -102,22 +104,30 @@ empathy_individual_menu_new (FolksIndividual *individual,
     }
 
   /* Invite */
-  item = empathy_individual_invite_menu_item_new (individual);
+  item = empathy_individual_invite_menu_item_new (individual, NULL);
   gtk_menu_shell_append (shell, item);
   gtk_widget_show (item);
 
   /* File transfer */
-  item = empathy_individual_file_transfer_menu_item_new (individual);
+  item = empathy_individual_file_transfer_menu_item_new (individual, NULL);
   gtk_menu_shell_append (shell, item);
   gtk_widget_show (item);
 
   /* Share my desktop */
   /* FIXME we should add the "Share my desktop" menu item if Vino is
   a registered handler in MC5 */
-  item = empathy_individual_share_my_desktop_menu_item_new (individual);
+  item = empathy_individual_share_my_desktop_menu_item_new (individual, NULL);
   gtk_menu_shell_append (shell, item);
   gtk_widget_show (item);
 
+  /* Menu items to target specific contacts */
+  item = empathy_individual_personas_menu_new (individual, features);
+  if (item != NULL)
+    {
+      gtk_menu_shell_append (shell, item);
+      gtk_widget_show (item);
+    }
+
   /* Separator */
   if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT |
       EMPATHY_INDIVIDUAL_FEATURE_INFO |
@@ -245,29 +255,80 @@ out:
   return item;
 }
 
-static void
-empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
-  FolksIndividual *individual)
+static gboolean
+menu_item_set_contact (GtkWidget *item,
+    EmpathyContact *contact,
+    GCallback activate_callback,
+    gboolean (sensitivity_predicate) (EmpathyContact *))
 {
-  EmpathyContact *contact;
+  gboolean contact_valid = TRUE;
 
-  contact = empathy_contact_dup_from_folks_individual (individual);
+  if (sensitivity_predicate)
+    {
+      contact_valid = sensitivity_predicate (contact);
+      gtk_widget_set_sensitive (item, sensitivity_predicate (contact));
+    }
 
-  g_return_if_fail (contact != NULL);
+  g_signal_connect (item, "activate", G_CALLBACK (activate_callback),
+      contact);
 
-  empathy_dispatcher_chat_with_contact (contact, gtk_get_current_event_time ());
+  return contact_valid;
+}
 
-  g_object_unref (contact);
+static GtkWidget *
+menu_item_set_first_contact (GtkWidget *item,
+    FolksIndividual *individual,
+    GCallback activate_callback,
+    gboolean (sensitivity_predicate) (EmpathyContact *))
+{
+  GList *personas, *l;
+
+  personas = folks_individual_get_personas (individual);
+  for (l = personas; l != NULL; l = l->next)
+    {
+      TpContact *tp_contact;
+      EmpathyContact *contact;
+      TpfPersona *persona = l->data;
+      gboolean contact_valid = TRUE;
+
+      if (!TPF_IS_PERSONA (persona))
+        continue;
+
+      tp_contact = tpf_persona_get_contact (persona);
+      contact = empathy_contact_dup_from_tp_contact (tp_contact);
+
+      contact_valid = menu_item_set_contact (item, contact,
+          G_CALLBACK (activate_callback), sensitivity_predicate);
+
+      g_object_unref (contact);
+
+      /* stop after the first valid match */
+      if (contact_valid)
+        break;
+    }
+
+  return item;
+}
+
+static void
+empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
+  EmpathyContact *contact)
+{
+  g_return_if_fail (EMPATHY_IS_CONTACT (contact));
+
+  empathy_dispatcher_chat_with_contact (contact, gtk_get_current_event_time ());
 }
 
 GtkWidget *
-empathy_individual_chat_menu_item_new (FolksIndividual *individual)
+empathy_individual_chat_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
 
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
-  g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
+  g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) &&
+      empathy_folks_individual_contains_contact (individual)) ||
+      EMPATHY_IS_CONTACT (contact),
       NULL);
 
   item = gtk_image_menu_item_new_with_mnemonic (_("_Chat"));
@@ -276,95 +337,101 @@ empathy_individual_chat_menu_item_new (FolksIndividual *individual)
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
   gtk_widget_show (image);
 
-  g_signal_connect (item, "activate",
-      G_CALLBACK (empathy_individual_chat_menu_item_activated), individual);
+  if (contact != NULL)
+    {
+      menu_item_set_contact (item, contact,
+          G_CALLBACK (empathy_individual_chat_menu_item_activated), NULL);
+    }
+  else
+    {
+      menu_item_set_first_contact (item, individual,
+          G_CALLBACK (empathy_individual_chat_menu_item_activated), NULL);
+    }
 
   return item;
 }
 
 static void
 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
-  FolksIndividual *individual)
+  EmpathyContact *contact)
 {
-  EmpathyContact *contact;
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 
   empathy_call_factory_new_call_with_streams (contact, TRUE, FALSE,
       gtk_get_current_event_time (), NULL);
-  g_object_unref (contact);
 }
 
 GtkWidget *
-empathy_individual_audio_call_menu_item_new (FolksIndividual *individual)
+empathy_individual_audio_call_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
-  EmpathyContact *contact;
 
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
-  g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
+      EMPATHY_IS_CONTACT (contact),
+      NULL);
 
   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
-  gtk_widget_set_sensitive (item, empathy_contact_can_voip_audio (contact));
   gtk_widget_show (image);
 
-  g_signal_connect (item, "activate",
-      G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
-      individual);
-
-  g_object_unref (contact);
+  if (contact != NULL)
+    {
+      menu_item_set_contact (item, contact,
+          G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
+          empathy_contact_can_voip_audio);
+    }
+  else
+    {
+      menu_item_set_first_contact (item, individual,
+          G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
+          empathy_contact_can_voip_audio);
+    }
 
   return item;
 }
 
 static void
 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
-  FolksIndividual *individual)
+  EmpathyContact *contact)
 {
-  EmpathyContact *contact;
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 
   empathy_call_factory_new_call_with_streams (contact, TRUE, TRUE,
       gtk_get_current_event_time (), NULL);
-  g_object_unref (contact);
 }
 
 GtkWidget *
-empathy_individual_video_call_menu_item_new (FolksIndividual *individual)
+empathy_individual_video_call_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
-  EmpathyContact *contact;
-
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
-  g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
+      EMPATHY_IS_CONTACT (contact),
+      NULL);
 
   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
       GTK_ICON_SIZE_MENU);
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
-  gtk_widget_set_sensitive (item, empathy_contact_can_voip_video (contact));
   gtk_widget_show (image);
 
-  g_signal_connect (item, "activate",
-      G_CALLBACK (empathy_individual_video_call_menu_item_activated),
-      individual);
-
-  g_object_unref (contact);
+  if (contact != NULL)
+    {
+      menu_item_set_contact (item, contact,
+          G_CALLBACK (empathy_individual_video_call_menu_item_activated),
+          empathy_contact_can_voip_video);
+    }
+  else
+    {
+      menu_item_set_first_contact (item, individual,
+          G_CALLBACK (empathy_individual_video_call_menu_item_activated),
+          empathy_contact_can_voip_video);
+    }
 
   return item;
 }
@@ -420,86 +487,200 @@ empathy_individual_log_menu_item_new (FolksIndividual *individual)
 }
 
 static void
-individual_file_transfer_menu_item_activate_cb (FolksIndividual *individual)
+empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
+    EmpathyContact *contact)
 {
-  EmpathyContact *contact;
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 
   empathy_send_file_with_file_chooser (contact);
-
-  g_object_unref (contact);
 }
 
 GtkWidget *
-empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual)
+empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
-  EmpathyContact *contact;
-
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
-  g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
+      EMPATHY_IS_CONTACT (contact),
+      NULL);
 
   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
-                GTK_ICON_SIZE_MENU);
-  gtk_widget_set_sensitive (item, empathy_contact_can_send_files (contact));
+      GTK_ICON_SIZE_MENU);
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
   gtk_widget_show (image);
 
-  g_signal_connect_swapped (item, "activate",
-      G_CALLBACK (individual_file_transfer_menu_item_activate_cb), individual);
-
-  g_object_unref (contact);
+  if (contact != NULL)
+    {
+      menu_item_set_contact (item, contact,
+          G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
+          empathy_contact_can_send_files);
+    }
+  else
+    {
+      menu_item_set_first_contact (item, individual,
+          G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
+          empathy_contact_can_send_files);
+    }
 
   return item;
 }
 
 static void
-individual_share_my_desktop_menu_item_activate_cb (FolksIndividual *individual)
+empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item,
+    EmpathyContact *contact)
 {
-  EmpathyContact *contact;
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-
   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 
   empathy_share_my_desktop_share_with_contact (contact);
-
-  g_object_unref (contact);
 }
 
 GtkWidget *
-empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual)
+empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
-  EmpathyContact *contact;
-
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
 
-  g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
+      EMPATHY_IS_CONTACT (contact),
+      NULL);
 
   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
-  gtk_widget_set_sensitive (item,
-      empathy_contact_can_use_rfb_stream_tube (contact));
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
   gtk_widget_show (image);
 
-  g_signal_connect_swapped (item, "activate",
-      G_CALLBACK (individual_share_my_desktop_menu_item_activate_cb),
-      individual);
+  if (contact != NULL)
+    {
+      menu_item_set_contact (item, contact,
+          G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
+          empathy_contact_can_use_rfb_stream_tube);
+    }
+  else
+    {
+      menu_item_set_first_contact (item, individual,
+          G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated),
+          empathy_contact_can_use_rfb_stream_tube);
+    }
 
-  g_object_unref (contact);
+  return item;
+}
+
+GtkWidget *
+empathy_individual_personas_menu_new (FolksIndividual *individual,
+    EmpathyIndividualFeatureFlags features)
+{
+  GtkWidget *item;
+  GtkWidget *image;
+  GtkWidget *submenu = NULL;
+  GList *personas, *l;
+  guint personas_added = 0;
+
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
+  g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
+      NULL);
+
+  item = gtk_image_menu_item_new_with_mnemonic (_("Pers_onas"));
+  image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE,
+      GTK_ICON_SIZE_MENU);
+  gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
+  gtk_widget_show (image);
+
+  submenu = gtk_menu_new ();
+
+  personas = folks_individual_get_personas (individual);
+  for (l = personas; l != NULL; l = l->next)
+    {
+      GtkWidget *contact_item;
+      GtkWidget *contact_submenu;
+      TpContact *tp_contact;
+      EmpathyContact *contact;
+      TpfPersona *persona = l->data;
+      gchar *label;
+      FolksPersonaStore *store;
+      const gchar *account;
+      GtkWidget *action;
+
+      if (!TPF_IS_PERSONA (persona))
+        continue;
+
+      tp_contact = tpf_persona_get_contact (persona);
+      contact = empathy_contact_dup_from_tp_contact (tp_contact);
+
+      label = g_strdup (
+          folks_persona_get_display_id (FOLKS_PERSONA (persona)));
+
+      store = folks_persona_get_store (FOLKS_PERSONA (persona));
+      account = folks_persona_store_get_display_name (store);
+      label = g_strdup_printf (_("%s (from %s)"),
+          folks_persona_get_display_id (FOLKS_PERSONA (persona)), account);
+
+      contact_item = gtk_image_menu_item_new_with_label (label);
+      contact_submenu = gtk_menu_new ();
+      gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_item), contact_submenu);
+      image = gtk_image_new_from_icon_name (
+          empathy_icon_name_for_contact (contact), GTK_ICON_SIZE_MENU);
+      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (contact_item), image);
+      gtk_widget_show (image);
+
+      /* Chat */
+      if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
+        {
+          action = empathy_individual_chat_menu_item_new (NULL, contact);
+          gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+          gtk_widget_show (action);
+        }
+
+      if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
+        {
+          /* Audio Call */
+          action = empathy_individual_audio_call_menu_item_new (NULL, contact);
+          gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+          gtk_widget_show (action);
+
+          /* Video Call */
+          action = empathy_individual_video_call_menu_item_new (NULL, contact);
+          gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+          gtk_widget_show (action);
+        }
+
+      /* Invite */
+      action = empathy_individual_invite_menu_item_new (NULL, contact);
+      gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+      gtk_widget_show (action);
+
+      /* File transfer */
+      action = empathy_individual_file_transfer_menu_item_new (NULL, contact);
+      gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+      gtk_widget_show (action);
+
+      /* Share my desktop */
+      action = empathy_individual_share_my_desktop_menu_item_new (NULL,
+          contact);
+      gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action);
+      gtk_widget_show (action);
+
+      gtk_menu_shell_append (GTK_MENU_SHELL (submenu), contact_item);
+      gtk_widget_show (contact_item);
+
+      personas_added++;
+
+      g_free (label);
+      g_object_unref (contact);
+    }
+
+  gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
+
+  if (personas_added > 0)
+    gtk_widget_show (submenu);
+  else
+    {
+      gtk_widget_destroy (item);
+      item = NULL;
+    }
 
   return item;
 }
@@ -531,12 +712,7 @@ empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
 static void
 individual_info_menu_item_activate_cb (FolksIndividual *individual)
 {
-  EmpathyContact *contact;
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
-  empathy_contact_information_dialog_show (contact, NULL);
-
-  tp_clear_object (&contact);
+  empathy_individual_information_dialog_show (individual, NULL);
 }
 
 GtkWidget *
@@ -650,25 +826,32 @@ empathy_individual_link_menu_item_new (FolksIndividual *individual)
 typedef struct
 {
   FolksIndividual *individual;
+  EmpathyContact *contact;
   EmpathyChatroom *chatroom;
 } RoomSubMenuData;
 
 static RoomSubMenuData *
 room_sub_menu_data_new (FolksIndividual *individual,
-      EmpathyChatroom *chatroom)
+    EmpathyContact *contact,
+    EmpathyChatroom *chatroom)
 {
   RoomSubMenuData *data;
 
-  data = g_slice_new (RoomSubMenuData);
-  data->individual = g_object_ref (individual);
+  data = g_slice_new0 (RoomSubMenuData);
+  if (individual != NULL)
+    data->individual = g_object_ref (individual);
+  if (contact != NULL)
+    data->contact = g_object_ref (contact);
   data->chatroom = g_object_ref (chatroom);
+
   return data;
 }
 
 static void
 room_sub_menu_data_free (RoomSubMenuData *data)
 {
-  g_object_unref (data->individual);
+  tp_clear_object (&data->individual);
+  tp_clear_object (&data->contact);
   g_object_unref (data->chatroom);
   g_slice_free (RoomSubMenuData, data);
 }
@@ -678,7 +861,9 @@ room_sub_menu_activate_cb (GtkWidget *item,
          RoomSubMenuData *data)
 {
   EmpathyTpChat *chat;
-  EmpathyContact *contact;
+  EmpathyChatroomManager *mgr;
+  EmpathyContact *contact = NULL;
+  GList *personas, *l;
 
   chat = empathy_chatroom_get_tp_chat (data->chatroom);
   if (chat == NULL)
@@ -687,7 +872,45 @@ room_sub_menu_activate_cb (GtkWidget *item,
       return;
     }
 
-  contact = empathy_contact_dup_from_folks_individual (data->individual);
+  mgr = empathy_chatroom_manager_dup_singleton (NULL);
+
+  if (data->contact != NULL)
+    contact = g_object_ref (data->contact);
+  else
+    {
+      /* find the first of this Individual's contacts who can join this room */
+      personas = folks_individual_get_personas (data->individual);
+      for (l = personas; l != NULL && contact == NULL; l = g_list_next (l))
+        {
+          TpfPersona *persona = l->data;
+          TpContact *tp_contact;
+          GList *rooms;
+
+          if (!TPF_IS_PERSONA (persona))
+            continue;
+
+          tp_contact = tpf_persona_get_contact (persona);
+          contact = empathy_contact_dup_from_tp_contact (tp_contact);
+
+          rooms = empathy_chatroom_manager_get_chatrooms (mgr,
+              empathy_contact_get_account (contact));
+
+          if (g_list_find (rooms, data->chatroom) == NULL)
+            tp_clear_object (&contact);
+
+          /* if contact != NULL here, we've found our match */
+
+          g_list_free (rooms);
+        }
+    }
+
+  g_object_unref (mgr);
+
+  if (contact == NULL)
+    {
+      /* contact disappeared. Ignoring */
+      goto out;
+    }
 
   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 
@@ -695,18 +918,20 @@ room_sub_menu_activate_cb (GtkWidget *item,
   empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat),
       contact, _("Inviting you to this room"));
 
+out:
   g_object_unref (contact);
 }
 
 static GtkWidget *
 create_room_sub_menu (FolksIndividual *individual,
+                      EmpathyContact *contact,
                       EmpathyChatroom *chatroom)
 {
   GtkWidget *item;
   RoomSubMenuData *data;
 
   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
-  data = room_sub_menu_data_new (individual, chatroom);
+  data = room_sub_menu_data_new (individual, contact, chatroom);
   g_signal_connect_data (item, "activate",
       G_CALLBACK (room_sub_menu_activate_cb), data,
       (GClosureNotify) room_sub_menu_data_free, 0);
@@ -715,21 +940,26 @@ create_room_sub_menu (FolksIndividual *individual,
 }
 
 GtkWidget *
-empathy_individual_invite_menu_item_new (FolksIndividual *individual)
+empathy_individual_invite_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact)
 {
   GtkWidget *item;
   GtkWidget *image;
   GtkWidget *room_item;
   EmpathyChatroomManager *mgr;
-  GList *rooms, *l;
+  GList *personas;
+  GList *rooms = NULL;
+  GList *names = NULL;
+  GList *l;
   GtkWidget *submenu = NULL;
-  EmpathyContact *contact;
+  GHashTable *name_room_map;
 
-  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
-
-  contact = empathy_contact_dup_from_folks_individual (individual);
+  g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) ||
+      EMPATHY_IS_CONTACT (contact),
+      NULL);
 
-  g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+  name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
+      g_object_unref);
 
   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
@@ -737,24 +967,75 @@ empathy_individual_invite_menu_item_new (FolksIndividual *individual)
   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 
   mgr = empathy_chatroom_manager_dup_singleton (NULL);
-  rooms = empathy_chatroom_manager_get_chatrooms (mgr,
-      empathy_contact_get_account (contact));
 
+  if (contact != NULL)
+    {
+      rooms = empathy_chatroom_manager_get_chatrooms (mgr,
+          empathy_contact_get_account (contact));
+    }
+  else
+    {
+      /* collect the rooms from amongst all accounts for this Individual */
+      personas = folks_individual_get_personas (individual);
+      for (l = personas; l != NULL; l = g_list_next (l))
+        {
+          TpfPersona *persona = l->data;
+          GList *rooms_cur;
+          TpContact *tp_contact;
+          EmpathyContact *contact_cur;
+
+          if (!TPF_IS_PERSONA (persona))
+            continue;
+
+          tp_contact = tpf_persona_get_contact (persona);
+          contact_cur = empathy_contact_dup_from_tp_contact (tp_contact);
+
+          rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
+              empathy_contact_get_account (contact_cur));
+          rooms = g_list_concat (rooms, rooms_cur);
+
+          g_object_unref (contact_cur);
+        }
+    }
+
+  /* alphabetize the rooms */
   for (l = rooms; l != NULL; l = g_list_next (l))
     {
       EmpathyChatroom *chatroom = l->data;
+      gboolean existed;
 
       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
         {
-          if (G_UNLIKELY (submenu == NULL))
-            submenu = gtk_menu_new ();
-
-          room_item = create_room_sub_menu (individual, chatroom);
-          gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
-          gtk_widget_show (room_item);
+          const gchar *name;
+
+          name = empathy_chatroom_get_name (chatroom);
+          existed = (g_hash_table_lookup (name_room_map, name) != NULL);
+          g_hash_table_insert (name_room_map, (gpointer) name,
+              g_object_ref (chatroom));
+
+          /* this will take care of duplicates in rooms */
+          if (!existed)
+            {
+              names = g_list_insert_sorted (names, (gpointer) name,
+                  (GCompareFunc) g_strcmp0);
+            }
         }
     }
 
+  for (l = names; l != NULL; l = g_list_next (l))
+    {
+      const gchar *name = l->data;
+      EmpathyChatroom *chatroom;
+
+      if (G_UNLIKELY (submenu == NULL))
+        submenu = gtk_menu_new ();
+
+      chatroom = g_hash_table_lookup (name_room_map, name);
+      room_item = create_room_sub_menu (individual, contact, chatroom);
+      gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
+      gtk_widget_show (room_item);
+    }
+
   if (submenu)
     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
   else
@@ -762,8 +1043,9 @@ empathy_individual_invite_menu_item_new (FolksIndividual *individual)
 
   gtk_widget_show (image);
 
-  g_object_unref (contact);
+  g_hash_table_destroy (name_room_map);
   g_object_unref (mgr);
+  g_list_free (names);
   g_list_free (rooms);
 
   return item;
diff --git a/libempathy-gtk/empathy-individual-menu.h b/libempathy-gtk/empathy-individual-menu.h
index 1c0d831..3de9aec 100644
--- a/libempathy-gtk/empathy-individual-menu.h
+++ b/libempathy-gtk/empathy-individual-menu.h
@@ -42,21 +42,29 @@ typedef enum {
 GtkWidget * empathy_individual_menu_new (FolksIndividual *individual,
     EmpathyIndividualFeatureFlags features);
 GtkWidget * empathy_individual_add_menu_item_new  (FolksIndividual *individual);
-GtkWidget * empathy_individual_chat_menu_item_new (FolksIndividual *individual);
+GtkWidget * empathy_individual_chat_menu_item_new (FolksIndividual *individual,
+    EmpathyContact *contact);
 GtkWidget * empathy_individual_audio_call_menu_item_new (
-    FolksIndividual *individual);
+    FolksIndividual *individual,
+    EmpathyContact *contact);
 GtkWidget * empathy_individual_video_call_menu_item_new (
-    FolksIndividual *individual);
+    FolksIndividual *individual,
+    EmpathyContact *contact);
 GtkWidget * empathy_individual_log_menu_item_new  (FolksIndividual *individual);
 GtkWidget * empathy_individual_info_menu_item_new (FolksIndividual *individual);
 GtkWidget * empathy_individual_edit_menu_item_new (FolksIndividual *individual);
 GtkWidget * empathy_individual_link_menu_item_new (FolksIndividual *individual);
 GtkWidget * empathy_individual_invite_menu_item_new (
-    FolksIndividual *individual);
+    FolksIndividual *individual,
+    EmpathyContact *contact);
 GtkWidget * empathy_individual_file_transfer_menu_item_new (
-    FolksIndividual *individual);
+    FolksIndividual *individual,
+    EmpathyContact *contact);
 GtkWidget * empathy_individual_share_my_desktop_menu_item_new (
-    FolksIndividual *individual);
+    FolksIndividual *individual,
+    EmpathyContact *contact);
+GtkWidget * empathy_individual_personas_menu_new (FolksIndividual *individual,
+    EmpathyIndividualFeatureFlags features);
 GtkWidget * empathy_individual_favourite_menu_item_new (
     FolksIndividual *individual);
 
diff --git a/libempathy-gtk/empathy-individual-view.c b/libempathy-gtk/empathy-individual-view.c
index 4e6db6c..ad777c9 100644
--- a/libempathy-gtk/empathy-individual-view.c
+++ b/libempathy-gtk/empathy-individual-view.c
@@ -960,12 +960,12 @@ individual_view_call_activated_cb (EmpathyCellRendererActivatable *cell,
   shell = GTK_MENU_SHELL (menu);
 
   /* audio */
-  item = empathy_individual_audio_call_menu_item_new (individual);
+  item = empathy_individual_audio_call_menu_item_new (individual, NULL);
   gtk_menu_shell_append (shell, item);
   gtk_widget_show (item);
 
   /* video */
-  item = empathy_individual_video_call_menu_item_new (individual);
+  item = empathy_individual_video_call_menu_item_new (individual, NULL);
   gtk_menu_shell_append (shell, item);
   gtk_widget_show (item);
 
