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 #include <telepathy-logger/log-manager.h>
  31 #include <folks/folks.h>
  32 #include <folks/folks-telepathy.h>
  33
  34 #include <libempathy/empathy-call-factory.h>
  35 #include <libempathy/empathy-dispatcher.h>
  36 #include <libempathy/empathy-contact-manager.h>
  37 #include <libempathy/empathy-individual-manager.h>
  38 #include <libempathy/empathy-chatroom-manager.h>
  39 #include <libempathy/empathy-utils.h>
  40
  41 #include "empathy-individual-menu.h"
  42 #include "empathy-images.h"
  43 #include "empathy-log-window.h"
  44 #include "empathy-contact-dialogs.h"
  45 #include "empathy-individual-dialogs.h"
  46 #include "empathy-individual-information-dialog.h"
  47 #include "empathy-ui-utils.h"
  48 #include "empathy-share-my-desktop.h"
  49 #include "empathy-linking-dialog.h"
  50
  51 GtkWidget *
  52 empathy_individual_menu_new (FolksIndividual *individual,
  53     EmpathyIndividualFeatureFlags features)
  54 {
  55   GtkWidget *menu;
  56   GtkMenuShell *shell;
  57   GtkWidget *item;
  58
  59   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
  60
  61   if (features == EMPATHY_INDIVIDUAL_FEATURE_NONE)
  62     return NULL;
  63
  64   menu = gtk_menu_new ();
  65   shell = GTK_MENU_SHELL (menu);
  66
  67   /* Add Contact */
  68   item = empathy_individual_add_menu_item_new (individual);
  69   if (item)
  70     {
  71       gtk_menu_shell_append (shell, item);
  72       gtk_widget_show (item);
  73     }
  74
  75   /* Chat */
  76   if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT)
  77     {
  78       item = empathy_individual_chat_menu_item_new (individual);
  79       if (item != NULL)
  80         {
  81           gtk_menu_shell_append (shell, item);
  82           gtk_widget_show (item);
  83         }
  84     }
  85
  86   if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL)
  87     {
  88       /* Audio Call */
  89       item = empathy_individual_audio_call_menu_item_new (individual);
  90       gtk_menu_shell_append (shell, item);
  91       gtk_widget_show (item);
  92
  93       /* Video Call */
  94       item = empathy_individual_video_call_menu_item_new (individual);
  95       gtk_menu_shell_append (shell, item);
  96       gtk_widget_show (item);
  97     }
  98
  99   /* Log */
 100   if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG)
 101     {
 102       item = empathy_individual_log_menu_item_new (individual);
 103       gtk_menu_shell_append (shell, item);
 104       gtk_widget_show (item);
 105     }
 106
 107   /* Invite */
 108   item = empathy_individual_invite_menu_item_new (individual);
 109   gtk_menu_shell_append (shell, item);
 110   gtk_widget_show (item);
 111
 112   /* File transfer */
 113   item = empathy_individual_file_transfer_menu_item_new (individual);
 114   gtk_menu_shell_append (shell, item);
 115   gtk_widget_show (item);
 116
 117   /* Share my desktop */
 118   /* FIXME we should add the "Share my desktop" menu item if Vino is
 119   a registered handler in MC5 */
 120   item = empathy_individual_share_my_desktop_menu_item_new (individual);
 121   gtk_menu_shell_append (shell, item);
 122   gtk_widget_show (item);
 123
 124   /* Separator */
 125   if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT |
 126       EMPATHY_INDIVIDUAL_FEATURE_INFO |
 127       EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE |
 128       EMPATHY_INDIVIDUAL_FEATURE_LINK))
 129     {
 130       item = gtk_separator_menu_item_new ();
 131       gtk_menu_shell_append (shell, item);
 132       gtk_widget_show (item);
 133     }
 134
 135   /* Edit */
 136   if (features & EMPATHY_INDIVIDUAL_FEATURE_EDIT)
 137     {
 138       item = empathy_individual_edit_menu_item_new (individual);
 139       gtk_menu_shell_append (shell, item);
 140       gtk_widget_show (item);
 141     }
 142
 143   /* Link */
 144   if (features & EMPATHY_INDIVIDUAL_FEATURE_LINK)
 145     {
 146       item = empathy_individual_link_menu_item_new (individual);
 147       gtk_menu_shell_append (shell, item);
 148       gtk_widget_show (item);
 149     }
 150
 151   /* Info */
 152   if (features & EMPATHY_INDIVIDUAL_FEATURE_INFO)
 153     {
 154       item = empathy_individual_info_menu_item_new (individual);
 155       gtk_menu_shell_append (shell, item);
 156       gtk_widget_show (item);
 157     }
 158
 159   /* Favorite checkbox */
 160   if (features & EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE)
 161     {
 162       item = empathy_individual_favourite_menu_item_new (individual);
 163       gtk_menu_shell_append (shell, item);
 164       gtk_widget_show (item);
 165     }
 166
 167   return menu;
 168 }
 169
 170 static void
 171 empathy_individual_add_menu_item_activated (GtkMenuItem *item,
 172   FolksIndividual *individual)
 173 {
 174   GtkWidget *toplevel;
 175
 176   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (item));
 177   if (!gtk_widget_is_toplevel (toplevel) || !GTK_IS_WINDOW (toplevel))
 178     toplevel = NULL;
 179
 180   empathy_new_individual_dialog_show_with_individual (GTK_WINDOW (toplevel),
 181       individual);
 182 }
 183
 184 GtkWidget *
 185 empathy_individual_add_menu_item_new (FolksIndividual *individual)
 186 {
 187   GtkWidget *item;
 188   GtkWidget *image;
 189   EmpathyIndividualManager *manager = NULL;
 190   EmpathyContact *contact = NULL;
 191   TpConnection *connection;
 192   GList *l, *members;
 193   gboolean found = FALSE;
 194   EmpathyIndividualManagerFlags flags;
 195
 196   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 197
 198   if (!empathy_individual_manager_initialized ())
 199     {
 200       item = NULL;
 201       goto out;
 202     }
 203
 204   manager = empathy_individual_manager_dup_singleton ();
 205   contact = empathy_contact_dup_from_folks_individual (individual);
 206   connection = empathy_contact_get_connection (contact);
 207
 208   flags = empathy_individual_manager_get_flags_for_connection (manager,
 209       connection);
 210
 211   if (!(flags & EMPATHY_INDIVIDUAL_MANAGER_CAN_ADD))
 212     {
 213       item = NULL;
 214       goto out;
 215     }
 216
 217   members = empathy_individual_manager_get_members (
 218       EMPATHY_INDIVIDUAL_MANAGER (manager));
 219
 220   for (l = members; l && !found; l = l->next)
 221     {
 222       if (!tp_strdiff (folks_individual_get_id (l->data),
 223               folks_individual_get_id (individual)))
 224         {
 225           found = TRUE;
 226         }
 227     }
 228   g_list_free (members);
 229
 230   if (found)
 231     {
 232       item = NULL;
 233       goto out;
 234     }
 235
 236   item = gtk_image_menu_item_new_with_mnemonic (_("_Add Contact…"));
 237   image = gtk_image_new_from_icon_name (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
 238   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 239
 240   g_signal_connect (item, "activate",
 241       G_CALLBACK (empathy_individual_add_menu_item_activated),
 242       individual);
 243
 244 out:
 245   tp_clear_object (&contact);
 246   tp_clear_object (&manager);
 247
 248   return item;
 249 }
 250
 251 typedef gboolean (*SensitivityPredicate) (EmpathyContact *contact);
 252
 253 /* Like menu_item_set_first_contact(), but always operates upon the given
 254  * contact */
 255 static gboolean
 256 menu_item_set_contact (GtkWidget *item,
 257     EmpathyContact *contact,
 258     GCallback activate_callback,
 259     SensitivityPredicate sensitivity_predicate)
 260 {
 261   gboolean contact_valid = TRUE;
 262
 263   if (sensitivity_predicate != NULL)
 264     {
 265       contact_valid = sensitivity_predicate (contact);
 266       gtk_widget_set_sensitive (item, sensitivity_predicate (contact));
 267     }
 268
 269   g_signal_connect (item, "activate", G_CALLBACK (activate_callback),
 270       contact);
 271
 272   return contact_valid;
 273 }
 274
 275 /**
 276  * Set the given menu @item to call @activate_callback upon the first valid
 277  * TpContact associated with @individual whenever @item is activated.
 278  *
 279  * @sensitivity_predicate is an optional function to determine whether the menu
 280  * item should be insensitive (if the function returns @FALSE). Otherwise, the
 281  * menu item's sensitivity will not change.
 282  */
 283 static GtkWidget *
 284 menu_item_set_first_contact (GtkWidget *item,
 285     FolksIndividual *individual,
 286     GCallback activate_callback,
 287     SensitivityPredicate sensitivity_predicate)
 288 {
 289   GList *personas, *l;
 290
 291   personas = folks_individual_get_personas (individual);
 292   for (l = personas; l != NULL; l = l->next)
 293     {
 294       TpContact *tp_contact;
 295       EmpathyContact *contact;
 296       TpfPersona *persona = l->data;
 297       gboolean contact_valid = TRUE;
 298
 299       if (!TPF_IS_PERSONA (persona))
 300         continue;
 301
 302       tp_contact = tpf_persona_get_contact (persona);
 303       contact = empathy_contact_dup_from_tp_contact (tp_contact);
 304
 305       contact_valid = menu_item_set_contact (item, contact,
 306           G_CALLBACK (activate_callback), sensitivity_predicate);
 307
 308       g_object_unref (contact);
 309
 310       /* stop after the first valid match */
 311       if (contact_valid)
 312         break;
 313     }
 314
 315   return item;
 316 }
 317
 318 static void
 319 empathy_individual_chat_menu_item_activated (GtkMenuItem *item,
 320   EmpathyContact *contact)
 321 {
 322   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 323
 324   empathy_dispatcher_chat_with_contact (contact, gtk_get_current_event_time ());
 325 }
 326
 327 GtkWidget *
 328 empathy_individual_chat_menu_item_new (FolksIndividual *individual)
 329 {
 330   GtkWidget *item;
 331   GtkWidget *image;
 332
 333   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 334   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
 335       NULL);
 336
 337   item = gtk_image_menu_item_new_with_mnemonic (_("_Chat"));
 338   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE,
 339       GTK_ICON_SIZE_MENU);
 340   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 341   gtk_widget_show (image);
 342
 343   menu_item_set_first_contact (item, individual,
 344       G_CALLBACK (empathy_individual_chat_menu_item_activated), NULL);
 345
 346   return item;
 347 }
 348
 349 static void
 350 empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item,
 351   EmpathyContact *contact)
 352 {
 353   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 354
 355   empathy_call_factory_new_call_with_streams (contact, TRUE, FALSE,
 356       gtk_get_current_event_time (), NULL);
 357 }
 358
 359 GtkWidget *
 360 empathy_individual_audio_call_menu_item_new (FolksIndividual *individual)
 361 {
 362   GtkWidget *item;
 363   GtkWidget *image;
 364
 365   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 366
 367   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call"));
 368   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU);
 369   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 370   gtk_widget_show (image);
 371
 372   menu_item_set_first_contact (item, individual,
 373       G_CALLBACK (empathy_individual_audio_call_menu_item_activated),
 374       empathy_contact_can_voip_audio);
 375
 376   return item;
 377 }
 378
 379 static void
 380 empathy_individual_video_call_menu_item_activated (GtkMenuItem *item,
 381   EmpathyContact *contact)
 382 {
 383   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 384
 385   empathy_call_factory_new_call_with_streams (contact, TRUE, TRUE,
 386       gtk_get_current_event_time (), NULL);
 387 }
 388
 389 GtkWidget *
 390 empathy_individual_video_call_menu_item_new (FolksIndividual *individual)
 391 {
 392   GtkWidget *item;
 393   GtkWidget *image;
 394
 395   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 396
 397   item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call"));
 398   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL,
 399       GTK_ICON_SIZE_MENU);
 400   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 401   gtk_widget_show (image);
 402
 403   menu_item_set_first_contact (item, individual,
 404       G_CALLBACK (empathy_individual_video_call_menu_item_activated),
 405       empathy_contact_can_voip_video);
 406
 407   return item;
 408 }
 409
 410 static void
 411 individual_log_menu_item_activate_cb (FolksIndividual *individual)
 412 {
 413   EmpathyContact *contact;
 414
 415   contact = empathy_contact_dup_from_folks_individual (individual);
 416
 417   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 418
 419   empathy_log_window_show (empathy_contact_get_account (contact),
 420       empathy_contact_get_id (contact), FALSE, NULL);
 421
 422   g_object_unref (contact);
 423 }
 424
 425 GtkWidget *
 426 empathy_individual_log_menu_item_new (FolksIndividual *individual)
 427 {
 428   TplLogManager *manager;
 429   gboolean have_log;
 430   GtkWidget *item;
 431   GtkWidget *image;
 432   EmpathyContact *contact;
 433
 434   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 435
 436   contact = empathy_contact_dup_from_folks_individual (individual);
 437
 438   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 439
 440   manager = tpl_log_manager_dup_singleton ();
 441   have_log = tpl_log_manager_exists (manager,
 442       empathy_contact_get_account (contact), empathy_contact_get_id (contact),
 443       FALSE);
 444   g_object_unref (manager);
 445
 446   item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations"));
 447   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU);
 448   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 449   gtk_widget_set_sensitive (item, have_log);
 450   gtk_widget_show (image);
 451
 452   g_signal_connect_swapped (item, "activate",
 453       G_CALLBACK (individual_log_menu_item_activate_cb), individual);
 454
 455   g_object_unref (contact);
 456
 457   return item;
 458 }
 459
 460 static void
 461 individual_file_transfer_menu_item_activate_cb (FolksIndividual *individual)
 462 {
 463   EmpathyContact *contact;
 464
 465   contact = empathy_contact_dup_from_folks_individual (individual);
 466
 467   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 468
 469   empathy_send_file_with_file_chooser (contact);
 470
 471   g_object_unref (contact);
 472 }
 473
 474 GtkWidget *
 475 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual)
 476 {
 477   GtkWidget *item;
 478   GtkWidget *image;
 479   EmpathyContact *contact;
 480
 481   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 482
 483   contact = empathy_contact_dup_from_folks_individual (individual);
 484
 485   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 486
 487   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
 488   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
 489                 GTK_ICON_SIZE_MENU);
 490   gtk_widget_set_sensitive (item, empathy_contact_can_send_files (contact));
 491   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 492   gtk_widget_show (image);
 493
 494   g_signal_connect_swapped (item, "activate",
 495       G_CALLBACK (individual_file_transfer_menu_item_activate_cb), individual);
 496
 497   g_object_unref (contact);
 498
 499   return item;
 500 }
 501
 502 static void
 503 individual_share_my_desktop_menu_item_activate_cb (FolksIndividual *individual)
 504 {
 505   EmpathyContact *contact;
 506
 507   contact = empathy_contact_dup_from_folks_individual (individual);
 508
 509   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 510
 511   empathy_share_my_desktop_share_with_contact (contact);
 512
 513   g_object_unref (contact);
 514 }
 515
 516 GtkWidget *
 517 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual)
 518 {
 519   GtkWidget *item;
 520   GtkWidget *image;
 521   EmpathyContact *contact;
 522
 523   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 524
 525   contact = empathy_contact_dup_from_folks_individual (individual);
 526
 527   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 528
 529   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
 530   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
 531   gtk_widget_set_sensitive (item,
 532       empathy_contact_can_use_rfb_stream_tube (contact));
 533   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 534   gtk_widget_show (image);
 535
 536   g_signal_connect_swapped (item, "activate",
 537       G_CALLBACK (individual_share_my_desktop_menu_item_activate_cb),
 538       individual);
 539
 540   g_object_unref (contact);
 541
 542   return item;
 543 }
 544
 545 static void
 546 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
 547   FolksIndividual *individual)
 548 {
 549   folks_favourite_set_is_favourite (FOLKS_FAVOURITE (individual),
 550       gtk_check_menu_item_get_active (item));
 551 }
 552
 553 GtkWidget *
 554 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
 555 {
 556   GtkWidget *item;
 557
 558   item = gtk_check_menu_item_new_with_label (_("Favorite"));
 559
 560   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
 561       folks_favourite_get_is_favourite (FOLKS_FAVOURITE (individual)));
 562
 563   g_signal_connect (item, "toggled",
 564       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
 565
 566   return item;
 567 }
 568
 569 static void
 570 individual_info_menu_item_activate_cb (FolksIndividual *individual)
 571 {
 572   empathy_individual_information_dialog_show (individual, NULL);
 573 }
 574
 575 GtkWidget *
 576 empathy_individual_info_menu_item_new (FolksIndividual *individual)
 577 {
 578   GtkWidget *item;
 579   GtkWidget *image;
 580
 581   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 582   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
 583       NULL);
 584
 585   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
 586   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
 587                 GTK_ICON_SIZE_MENU);
 588   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 589   gtk_widget_show (image);
 590
 591   g_signal_connect_swapped (item, "activate",
 592           G_CALLBACK (individual_info_menu_item_activate_cb),
 593           individual);
 594
 595   return item;
 596 }
 597
 598 static void
 599 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
 600 {
 601   EmpathyContact *contact;
 602
 603   contact = empathy_contact_dup_from_folks_individual (individual);
 604   empathy_contact_edit_dialog_show (contact, NULL);
 605
 606   tp_clear_object (&contact);
 607 }
 608
 609 GtkWidget *
 610 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
 611 {
 612   EmpathyIndividualManager *manager;
 613   GtkWidget *item;
 614   GtkWidget *image;
 615   gboolean enable = FALSE;
 616   EmpathyContact *contact;
 617
 618   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 619
 620   contact = empathy_contact_dup_from_folks_individual (individual);
 621
 622   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 623
 624   if (empathy_individual_manager_initialized ())
 625     {
 626       TpConnection *connection;
 627       EmpathyIndividualManagerFlags flags;
 628
 629       manager = empathy_individual_manager_dup_singleton ();
 630       connection = empathy_contact_get_connection (contact);
 631       flags = empathy_individual_manager_get_flags_for_connection (
 632           manager, connection);
 633
 634       enable = (flags & EMPATHY_INDIVIDUAL_MANAGER_CAN_ALIAS ||
 635                 flags & EMPATHY_INDIVIDUAL_MANAGER_CAN_GROUP);
 636
 637       g_object_unref (manager);
 638     }
 639
 640   item = gtk_image_menu_item_new_with_mnemonic (
 641       C_("Edit individual (contextual menu)", "_Edit"));
 642   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
 643   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 644   gtk_widget_show (image);
 645
 646   gtk_widget_set_sensitive (item, enable);
 647
 648   g_signal_connect_swapped (item, "activate",
 649       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
 650
 651   g_object_unref (contact);
 652
 653   return item;
 654 }
 655
 656 static void
 657 individual_link_menu_item_activate_cb (FolksIndividual *individual)
 658 {
 659   empathy_linking_dialog_show (individual, NULL);
 660 }
 661
 662 GtkWidget *
 663 empathy_individual_link_menu_item_new (FolksIndividual *individual)
 664 {
 665   GtkWidget *item;
 666   /*GtkWidget *image;*/
 667
 668   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 669
 670   item = gtk_image_menu_item_new_with_mnemonic (
 671       C_("Link individual (contextual menu)", "_Link…"));
 672   /* TODO */
 673   /*image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
 674   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 675   gtk_widget_show (image);*/
 676
 677   g_signal_connect_swapped (item, "activate",
 678       G_CALLBACK (individual_link_menu_item_activate_cb), individual);
 679
 680   return item;
 681 }
 682
 683 typedef struct
 684 {
 685   FolksIndividual *individual;
 686   EmpathyChatroom *chatroom;
 687 } RoomSubMenuData;
 688
 689 static RoomSubMenuData *
 690 room_sub_menu_data_new (FolksIndividual *individual,
 691       EmpathyChatroom *chatroom)
 692 {
 693   RoomSubMenuData *data;
 694
 695   data = g_slice_new (RoomSubMenuData);
 696   data->individual = g_object_ref (individual);
 697   data->chatroom = g_object_ref (chatroom);
 698   return data;
 699 }
 700
 701 static void
 702 room_sub_menu_data_free (RoomSubMenuData *data)
 703 {
 704   g_object_unref (data->individual);
 705   g_object_unref (data->chatroom);
 706   g_slice_free (RoomSubMenuData, data);
 707 }
 708
 709 static void
 710 room_sub_menu_activate_cb (GtkWidget *item,
 711          RoomSubMenuData *data)
 712 {
 713   EmpathyTpChat *chat;
 714   EmpathyContact *contact;
 715
 716   chat = empathy_chatroom_get_tp_chat (data->chatroom);
 717   if (chat == NULL)
 718     {
 719       /* channel was invalidated. Ignoring */
 720       return;
 721     }
 722
 723   contact = empathy_contact_dup_from_folks_individual (data->individual);
 724
 725   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 726
 727   /* send invitation */
 728   empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat),
 729       contact, _("Inviting you to this room"));
 730
 731   g_object_unref (contact);
 732 }
 733
 734 static GtkWidget *
 735 create_room_sub_menu (FolksIndividual *individual,
 736                       EmpathyChatroom *chatroom)
 737 {
 738   GtkWidget *item;
 739   RoomSubMenuData *data;
 740
 741   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
 742   data = room_sub_menu_data_new (individual, chatroom);
 743   g_signal_connect_data (item, "activate",
 744       G_CALLBACK (room_sub_menu_activate_cb), data,
 745       (GClosureNotify) room_sub_menu_data_free, 0);
 746
 747   return item;
 748 }
 749
 750 GtkWidget *
 751 empathy_individual_invite_menu_item_new (FolksIndividual *individual)
 752 {
 753   GtkWidget *item;
 754   GtkWidget *image;
 755   GtkWidget *room_item;
 756   EmpathyChatroomManager *mgr;
 757   GList *rooms, *l;
 758   GtkWidget *submenu = NULL;
 759   EmpathyContact *contact;
 760
 761   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 762
 763   contact = empathy_contact_dup_from_folks_individual (individual);
 764
 765   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 766
 767   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
 768   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
 769       GTK_ICON_SIZE_MENU);
 770   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 771
 772   mgr = empathy_chatroom_manager_dup_singleton (NULL);
 773   rooms = empathy_chatroom_manager_get_chatrooms (mgr,
 774       empathy_contact_get_account (contact));
 775
 776   for (l = rooms; l != NULL; l = g_list_next (l))
 777     {
 778       EmpathyChatroom *chatroom = l->data;
 779
 780       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
 781         {
 782           if (G_UNLIKELY (submenu == NULL))
 783             submenu = gtk_menu_new ();
 784
 785           room_item = create_room_sub_menu (individual, chatroom);
 786           gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
 787           gtk_widget_show (room_item);
 788         }
 789     }
 790
 791   if (submenu)
 792     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
 793   else
 794     gtk_widget_set_sensitive (item, FALSE);
 795
 796   gtk_widget_show (image);
 797
 798   g_object_unref (contact);
 799   g_object_unref (mgr);
 800   g_list_free (rooms);
 801
 802   return item;
 803 }