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