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