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 empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item,
 462     EmpathyContact *contact)
 463 {
 464   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 465
 466   empathy_send_file_with_file_chooser (contact);
 467 }
 468
 469 GtkWidget *
 470 empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual)
 471 {
 472   GtkWidget *item;
 473   GtkWidget *image;
 474
 475   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 476
 477   item = gtk_image_menu_item_new_with_mnemonic (_("Send File"));
 478   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND,
 479       GTK_ICON_SIZE_MENU);
 480   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 481   gtk_widget_show (image);
 482
 483   menu_item_set_first_contact (item, individual,
 484       G_CALLBACK (empathy_individual_file_transfer_menu_item_activated),
 485       empathy_contact_can_send_files);
 486
 487   return item;
 488 }
 489
 490 static void
 491 individual_share_my_desktop_menu_item_activate_cb (FolksIndividual *individual)
 492 {
 493   EmpathyContact *contact;
 494
 495   contact = empathy_contact_dup_from_folks_individual (individual);
 496
 497   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 498
 499   empathy_share_my_desktop_share_with_contact (contact);
 500
 501   g_object_unref (contact);
 502 }
 503
 504 GtkWidget *
 505 empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual)
 506 {
 507   GtkWidget *item;
 508   GtkWidget *image;
 509   EmpathyContact *contact;
 510
 511   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 512
 513   contact = empathy_contact_dup_from_folks_individual (individual);
 514
 515   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 516
 517   item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop"));
 518   image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU);
 519   gtk_widget_set_sensitive (item,
 520       empathy_contact_can_use_rfb_stream_tube (contact));
 521   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 522   gtk_widget_show (image);
 523
 524   g_signal_connect_swapped (item, "activate",
 525       G_CALLBACK (individual_share_my_desktop_menu_item_activate_cb),
 526       individual);
 527
 528   g_object_unref (contact);
 529
 530   return item;
 531 }
 532
 533 static void
 534 favourite_menu_item_toggled_cb (GtkCheckMenuItem *item,
 535   FolksIndividual *individual)
 536 {
 537   folks_favourite_set_is_favourite (FOLKS_FAVOURITE (individual),
 538       gtk_check_menu_item_get_active (item));
 539 }
 540
 541 GtkWidget *
 542 empathy_individual_favourite_menu_item_new (FolksIndividual *individual)
 543 {
 544   GtkWidget *item;
 545
 546   item = gtk_check_menu_item_new_with_label (_("Favorite"));
 547
 548   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
 549       folks_favourite_get_is_favourite (FOLKS_FAVOURITE (individual)));
 550
 551   g_signal_connect (item, "toggled",
 552       G_CALLBACK (favourite_menu_item_toggled_cb), individual);
 553
 554   return item;
 555 }
 556
 557 static void
 558 individual_info_menu_item_activate_cb (FolksIndividual *individual)
 559 {
 560   empathy_individual_information_dialog_show (individual, NULL);
 561 }
 562
 563 GtkWidget *
 564 empathy_individual_info_menu_item_new (FolksIndividual *individual)
 565 {
 566   GtkWidget *item;
 567   GtkWidget *image;
 568
 569   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 570   g_return_val_if_fail (empathy_folks_individual_contains_contact (individual),
 571       NULL);
 572
 573   item = gtk_image_menu_item_new_with_mnemonic (_("Infor_mation"));
 574   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_CONTACT_INFORMATION,
 575                 GTK_ICON_SIZE_MENU);
 576   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 577   gtk_widget_show (image);
 578
 579   g_signal_connect_swapped (item, "activate",
 580           G_CALLBACK (individual_info_menu_item_activate_cb),
 581           individual);
 582
 583   return item;
 584 }
 585
 586 static void
 587 individual_edit_menu_item_activate_cb (FolksIndividual *individual)
 588 {
 589   EmpathyContact *contact;
 590
 591   contact = empathy_contact_dup_from_folks_individual (individual);
 592   empathy_contact_edit_dialog_show (contact, NULL);
 593
 594   tp_clear_object (&contact);
 595 }
 596
 597 GtkWidget *
 598 empathy_individual_edit_menu_item_new (FolksIndividual *individual)
 599 {
 600   EmpathyIndividualManager *manager;
 601   GtkWidget *item;
 602   GtkWidget *image;
 603   gboolean enable = FALSE;
 604   EmpathyContact *contact;
 605
 606   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 607
 608   contact = empathy_contact_dup_from_folks_individual (individual);
 609
 610   g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
 611
 612   if (empathy_individual_manager_initialized ())
 613     {
 614       TpConnection *connection;
 615       EmpathyIndividualManagerFlags flags;
 616
 617       manager = empathy_individual_manager_dup_singleton ();
 618       connection = empathy_contact_get_connection (contact);
 619       flags = empathy_individual_manager_get_flags_for_connection (
 620           manager, connection);
 621
 622       enable = (flags & EMPATHY_INDIVIDUAL_MANAGER_CAN_ALIAS ||
 623                 flags & EMPATHY_INDIVIDUAL_MANAGER_CAN_GROUP);
 624
 625       g_object_unref (manager);
 626     }
 627
 628   item = gtk_image_menu_item_new_with_mnemonic (
 629       C_("Edit individual (contextual menu)", "_Edit"));
 630   image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
 631   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 632   gtk_widget_show (image);
 633
 634   gtk_widget_set_sensitive (item, enable);
 635
 636   g_signal_connect_swapped (item, "activate",
 637       G_CALLBACK (individual_edit_menu_item_activate_cb), individual);
 638
 639   g_object_unref (contact);
 640
 641   return item;
 642 }
 643
 644 static void
 645 individual_link_menu_item_activate_cb (FolksIndividual *individual)
 646 {
 647   empathy_linking_dialog_show (individual, NULL);
 648 }
 649
 650 GtkWidget *
 651 empathy_individual_link_menu_item_new (FolksIndividual *individual)
 652 {
 653   GtkWidget *item;
 654   /*GtkWidget *image;*/
 655
 656   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 657
 658   item = gtk_image_menu_item_new_with_mnemonic (
 659       C_("Link individual (contextual menu)", "_Link…"));
 660   /* TODO */
 661   /*image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
 662   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 663   gtk_widget_show (image);*/
 664
 665   g_signal_connect_swapped (item, "activate",
 666       G_CALLBACK (individual_link_menu_item_activate_cb), individual);
 667
 668   return item;
 669 }
 670
 671 typedef struct
 672 {
 673   FolksIndividual *individual;
 674   EmpathyChatroom *chatroom;
 675 } RoomSubMenuData;
 676
 677 static RoomSubMenuData *
 678 room_sub_menu_data_new (FolksIndividual *individual,
 679       EmpathyChatroom *chatroom)
 680 {
 681   RoomSubMenuData *data;
 682
 683   data = g_slice_new (RoomSubMenuData);
 684   data->individual = g_object_ref (individual);
 685   data->chatroom = g_object_ref (chatroom);
 686   return data;
 687 }
 688
 689 static void
 690 room_sub_menu_data_free (RoomSubMenuData *data)
 691 {
 692   g_object_unref (data->individual);
 693   g_object_unref (data->chatroom);
 694   g_slice_free (RoomSubMenuData, data);
 695 }
 696
 697 static void
 698 room_sub_menu_activate_cb (GtkWidget *item,
 699          RoomSubMenuData *data)
 700 {
 701   EmpathyTpChat *chat;
 702   EmpathyChatroomManager *mgr;
 703   EmpathyContact *contact = NULL;
 704   GList *personas, *l;
 705
 706   chat = empathy_chatroom_get_tp_chat (data->chatroom);
 707   if (chat == NULL)
 708     {
 709       /* channel was invalidated. Ignoring */
 710       return;
 711     }
 712
 713   mgr = empathy_chatroom_manager_dup_singleton (NULL);
 714
 715   /* find the first of this Individual's contacts who can join this room */
 716   personas = folks_individual_get_personas (data->individual);
 717   for (l = personas; l != NULL && contact == NULL; l = g_list_next (l))
 718     {
 719       TpfPersona *persona = l->data;
 720       TpContact *tp_contact;
 721       GList *rooms;
 722
 723       if (!TPF_IS_PERSONA (persona))
 724         continue;
 725
 726       tp_contact = tpf_persona_get_contact (persona);
 727       contact = empathy_contact_dup_from_tp_contact (tp_contact);
 728
 729       rooms = empathy_chatroom_manager_get_chatrooms (mgr,
 730           empathy_contact_get_account (contact));
 731
 732       if (g_list_find (rooms, data->chatroom) == NULL)
 733         tp_clear_object (&contact);
 734
 735       /* if contact != NULL here, we've found our match */
 736
 737       g_list_free (rooms);
 738     }
 739
 740   g_object_unref (mgr);
 741
 742   if (contact == NULL)
 743     {
 744       /* contact disappeared. Ignoring */
 745       return;
 746     }
 747
 748   g_return_if_fail (EMPATHY_IS_CONTACT (contact));
 749
 750   /* send invitation */
 751   empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat),
 752       contact, _("Inviting you to this room"));
 753
 754   g_object_unref (contact);
 755 }
 756
 757 static GtkWidget *
 758 create_room_sub_menu (FolksIndividual *individual,
 759                       EmpathyChatroom *chatroom)
 760 {
 761   GtkWidget *item;
 762   RoomSubMenuData *data;
 763
 764   item = gtk_menu_item_new_with_label (empathy_chatroom_get_name (chatroom));
 765   data = room_sub_menu_data_new (individual, chatroom);
 766   g_signal_connect_data (item, "activate",
 767       G_CALLBACK (room_sub_menu_activate_cb), data,
 768       (GClosureNotify) room_sub_menu_data_free, 0);
 769
 770   return item;
 771 }
 772
 773 GtkWidget *
 774 empathy_individual_invite_menu_item_new (FolksIndividual *individual)
 775 {
 776   GtkWidget *item;
 777   GtkWidget *image;
 778   GtkWidget *room_item;
 779   EmpathyChatroomManager *mgr;
 780   GList *personas;
 781   GList *rooms = NULL;
 782   GList *names = NULL;
 783   GList *l;
 784   GtkWidget *submenu = NULL;
 785   /* map of chat room names to their objects; just a utility to remove
 786    * duplicates and to make construction of the alphabetized list easier */
 787   GHashTable *name_room_map;
 788
 789   g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
 790
 791   name_room_map = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
 792       g_object_unref);
 793
 794   item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
 795   image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
 796       GTK_ICON_SIZE_MENU);
 797   gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
 798
 799   mgr = empathy_chatroom_manager_dup_singleton (NULL);
 800
 801   /* collect the rooms from amongst all accounts for this Individual */
 802   personas = folks_individual_get_personas (individual);
 803   for (l = personas; l != NULL; l = g_list_next (l))
 804     {
 805       TpfPersona *persona = l->data;
 806       GList *rooms_cur;
 807       TpContact *tp_contact;
 808       EmpathyContact *contact;
 809
 810       if (!TPF_IS_PERSONA (persona))
 811         continue;
 812
 813       tp_contact = tpf_persona_get_contact (persona);
 814       contact = empathy_contact_dup_from_tp_contact (tp_contact);
 815
 816       rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
 817           empathy_contact_get_account (contact));
 818       rooms = g_list_concat (rooms, rooms_cur);
 819
 820       g_object_unref (contact);
 821     }
 822
 823   /* alphabetize the rooms */
 824   for (l = rooms; l != NULL; l = g_list_next (l))
 825     {
 826       EmpathyChatroom *chatroom = l->data;
 827       gboolean existed;
 828
 829       if (empathy_chatroom_get_tp_chat (chatroom) != NULL)
 830         {
 831           const gchar *name;
 832
 833           name = empathy_chatroom_get_name (chatroom);
 834           existed = (g_hash_table_lookup (name_room_map, name) != NULL);
 835           g_hash_table_insert (name_room_map, (gpointer) name,
 836               g_object_ref (chatroom));
 837
 838           /* this will take care of duplicates in rooms */
 839           if (!existed)
 840             {
 841               names = g_list_insert_sorted (names, (gpointer) name,
 842                   (GCompareFunc) g_strcmp0);
 843             }
 844         }
 845     }
 846
 847   for (l = names; l != NULL; l = g_list_next (l))
 848     {
 849       const gchar *name = l->data;
 850       EmpathyChatroom *chatroom;
 851
 852       if (G_UNLIKELY (submenu == NULL))
 853         submenu = gtk_menu_new ();
 854
 855       chatroom = g_hash_table_lookup (name_room_map, name);
 856       room_item = create_room_sub_menu (individual, chatroom);
 857       gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
 858       gtk_widget_show (room_item);
 859     }
 860
 861   if (submenu)
 862     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
 863   else
 864     gtk_widget_set_sensitive (item, FALSE);
 865
 866   gtk_widget_show (image);
 867
 868   g_hash_table_destroy (name_room_map);
 869   g_object_unref (mgr);
 870   g_list_free (names);
 871   g_list_free (rooms);
 872
 873   return item;
 874 }