X-Git-Url: https://git.0d.be/?p=empathy.git;a=blobdiff_plain;f=libempathy-gtk%2Fempathy-individual-menu.c;h=5dc1309839142c6c0bcda24124c97ee2c61070ef;hp=2209e1538915861cf476bdda6c256f5782b72d6b;hb=bcd1f9ac9f8cae420e1f9616d94b9b518c740704;hpb=fecbf935f2b9be2cd6229099334279028fc517f1 diff --git a/libempathy-gtk/empathy-individual-menu.c b/libempathy-gtk/empathy-individual-menu.c index 2209e153..5dc13098 100644 --- a/libempathy-gtk/empathy-individual-menu.c +++ b/libempathy-gtk/empathy-individual-menu.c @@ -21,61 +21,87 @@ */ #include "config.h" - -#include +#include "empathy-individual-menu.h" #include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include +#include +#include #include "empathy-account-selector-dialog.h" -#include "empathy-individual-menu.h" -#include "empathy-images.h" -#include "empathy-log-window.h" -#include "empathy-contact-dialogs.h" +#include "empathy-call-utils.h" +#include "empathy-chatroom-manager.h" #include "empathy-gtk-enum-types.h" +#include "empathy-images.h" +#include "empathy-individual-dialogs.h" +#include "empathy-individual-dialogs.h" #include "empathy-individual-edit-dialog.h" #include "empathy-individual-information-dialog.h" -#include "empathy-ui-utils.h" +#include "empathy-individual-manager.h" +#include "empathy-individual-store-channel.h" +#include "empathy-log-window.h" +#include "empathy-request-util.h" #include "empathy-share-my-desktop.h" -#include "empathy-linking-dialog.h" -#include "empathy-call-utils.h" +#include "empathy-ui-utils.h" +#include "empathy-utils.h" #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT -#include +#include "empathy-debug.h" #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIndividualMenu) typedef struct { + gchar *active_group; /* may be NULL */ FolksIndividual *individual; /* owned */ EmpathyIndividualFeatureFlags features; + EmpathyIndividualStore *store; /* may be NULL */ } EmpathyIndividualMenuPriv; enum { - PROP_INDIVIDUAL = 1, + PROP_ACTIVE_GROUP = 1, + PROP_INDIVIDUAL, PROP_FEATURES, + PROP_STORE, }; enum { - SIGNAL_LINK_CONTACTS_ACTIVATED, + MENU_ITEM_ACTIVATED, LAST_SIGNAL }; -static guint signals[LAST_SIGNAL]; +static guint signals [LAST_SIGNAL] = { 0 }; G_DEFINE_TYPE (EmpathyIndividualMenu, empathy_individual_menu, GTK_TYPE_MENU); +static GtkWidget * empathy_individual_chat_menu_item_new ( + EmpathyIndividualMenu *self, FolksIndividual *individual); +static GtkWidget * empathy_individual_sms_menu_item_new ( + EmpathyIndividualMenu *self, FolksIndividual *individual); +static GtkWidget * empathy_individual_log_menu_item_new ( + FolksIndividual *individual); +static GtkWidget * empathy_individual_info_menu_item_new ( + FolksIndividual *individual); +static GtkWidget * empathy_individual_edit_menu_item_new ( + FolksIndividual *individual); +static GtkWidget * empathy_individual_invite_menu_item_new ( + FolksIndividual *individual, + EmpathyContact *contact); +static GtkWidget * empathy_individual_file_transfer_menu_item_new ( + EmpathyIndividualMenu *self, FolksIndividual *individual); +static GtkWidget * empathy_individual_share_my_desktop_menu_item_new ( + EmpathyIndividualMenu *self, FolksIndividual *individual); +static GtkWidget * empathy_individual_favourite_menu_item_new ( + FolksIndividual *individual); +static GtkWidget * empathy_individual_add_menu_item_new ( + EmpathyIndividualMenu *self, + FolksIndividual *individual); +static GtkWidget * empathy_individiual_block_menu_item_new ( + FolksIndividual *individual); +static GtkWidget * empathy_individiual_remove_menu_item_new ( + EmpathyIndividualMenu *self); + static void -individual_menu_add_personas (GtkMenuShell *menu, +individual_menu_add_personas (EmpathyIndividualMenu *self, + GtkMenuShell *menu, FolksIndividual *individual, EmpathyIndividualFeatureFlags features) { @@ -83,7 +109,6 @@ individual_menu_add_personas (GtkMenuShell *menu, GeeSet *personas; GeeIterator *iter; guint persona_count = 0; - gboolean c; g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual)); @@ -106,15 +131,15 @@ individual_menu_add_personas (GtkMenuShell *menu, /* return early if these entries would add nothing beyond the "quick" items */ if (persona_count <= 1) - return; + goto out; /* add a separator before the list of personas */ item = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); - personas = folks_individual_get_personas (individual); - for (c = gee_iterator_first (iter); c; c = gee_iterator_next (iter)) + iter = gee_iterable_iterator (GEE_ITERABLE (personas)); + while (gee_iterator_next (iter)) { GtkWidget *image; GtkWidget *contact_item; @@ -126,6 +151,8 @@ individual_menu_add_personas (GtkMenuShell *menu, FolksPersonaStore *store; const gchar *account; GtkWidget *action; + /* Individual containing only persona */ + FolksIndividual *single_individual; if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona))) goto while_finish; @@ -135,6 +162,13 @@ individual_menu_add_personas (GtkMenuShell *menu, goto while_finish; contact = empathy_contact_dup_from_tp_contact (tp_contact); + single_individual = empathy_create_individual_from_tp_contact ( + tp_contact); + + /* Pretty hacky. Creating single_individual had a side effect to change + * persona.individual from individual to single_individual which is not + * what we want so we set it back. See bgo#684971 for details. */ + g_object_set (persona, "individual", individual, NULL); store = folks_persona_get_store (FOLKS_PERSONA (persona)); account = folks_persona_store_get_display_name (store); @@ -158,7 +192,8 @@ individual_menu_add_personas (GtkMenuShell *menu, /* Chat */ if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT) { - action = empathy_individual_chat_menu_item_new (NULL, contact); + action = empathy_individual_chat_menu_item_new (self, + single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); } @@ -166,7 +201,8 @@ individual_menu_add_personas (GtkMenuShell *menu, /* SMS */ if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS) { - action = empathy_individual_sms_menu_item_new (NULL, contact); + action = empathy_individual_sms_menu_item_new (self, + single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); } @@ -174,12 +210,14 @@ individual_menu_add_personas (GtkMenuShell *menu, if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL) { /* Audio Call */ - action = empathy_individual_audio_call_menu_item_new (NULL, contact); + action = empathy_individual_audio_call_menu_item_new ( + self, single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); /* Video Call */ - action = empathy_individual_video_call_menu_item_new (NULL, contact); + action = empathy_individual_video_call_menu_item_new ( + self, single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); } @@ -187,7 +225,7 @@ individual_menu_add_personas (GtkMenuShell *menu, /* Log */ if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG) { - action = empathy_individual_log_menu_item_new (NULL, contact); + action = empathy_individual_log_menu_item_new (single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); } @@ -198,39 +236,49 @@ individual_menu_add_personas (GtkMenuShell *menu, gtk_widget_show (action); /* File transfer */ - action = empathy_individual_file_transfer_menu_item_new (NULL, contact); - gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); - gtk_widget_show (action); + if (features & EMPATHY_INDIVIDUAL_FEATURE_FILE_TRANSFER) + { + action = empathy_individual_file_transfer_menu_item_new ( + self, single_individual); + gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); + gtk_widget_show (action); + } /* Share my desktop */ - action = empathy_individual_share_my_desktop_menu_item_new (NULL, - contact); + action = empathy_individual_share_my_desktop_menu_item_new ( + self, single_individual); gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), action); gtk_widget_show (action); + /* Block */ + if (features & EMPATHY_INDIVIDUAL_FEATURE_BLOCK && + (item = empathy_individiual_block_menu_item_new (single_individual)) + != NULL) { + GtkWidget *sep; + + sep = gtk_separator_menu_item_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), sep); + gtk_widget_show (sep); + + gtk_menu_shell_append (GTK_MENU_SHELL (contact_submenu), item); + gtk_widget_show (item); + } + gtk_menu_shell_append (GTK_MENU_SHELL (menu), contact_item); gtk_widget_show (contact_item); g_free (label); g_object_unref (contact); + g_object_unref (single_individual); while_finish: g_clear_object (&persona); } +out: g_clear_object (&iter); } -static void -individual_link_menu_item_activate_cb (EmpathyIndividualMenu *self) -{ - EmpathyIndividualMenuPriv *priv = GET_PRIV (self); - GtkWidget *dialog; - - dialog = empathy_linking_dialog_show (priv->individual, NULL); - g_signal_emit (self, signals[SIGNAL_LINK_CONTACTS_ACTIVATED], 0, dialog); -} - static void empathy_individual_menu_init (EmpathyIndividualMenu *self) { @@ -250,7 +298,7 @@ find_phone_accounts (void) am = tp_account_manager_dup (); g_return_val_if_fail (am != NULL, NULL); - accounts = tp_account_manager_get_valid_accounts (am); + accounts = tp_account_manager_dup_valid_accounts (am); for (l = accounts; l != NULL; l = g_list_next (l)) { TpAccount *account = l->data; @@ -259,13 +307,13 @@ find_phone_accounts (void) TP_CONNECTION_STATUS_CONNECTED) continue; - if (!empathy_account_has_uri_scheme_tel (account)) + if (!tp_account_associated_with_uri_scheme (account, "tel")) continue; found = g_list_prepend (found, g_object_ref (account)); } - g_list_free (accounts); + g_list_free_full (accounts, g_object_unref); g_object_unref (am); return found; @@ -410,13 +458,16 @@ add_phone_numbers (EmpathyIndividualMenu *self) if (type != NULL) { - tmp = g_strdup_printf ("Call %s (%s)", + /* translators: first argument is a phone number like +32123456 and + * the second one is something like 'home' or 'work'. */ + tmp = g_strdup_printf (_("Call %s (%s)"), folks_phone_field_details_get_normalised (details), type); } else { - tmp = g_strdup_printf ("Call %s", + /* translators: argument is a phone number like +32123456 */ + tmp = g_strdup_printf (_("Call %s"), folks_phone_field_details_get_normalised (details)); } @@ -437,12 +488,466 @@ add_phone_numbers (EmpathyIndividualMenu *self) gtk_menu_shell_append (GTK_MENU_SHELL (self), item); gtk_widget_show (item); } + + g_object_unref (iter); +} + +/* return a list of TpContact supporting the blocking iface */ +static GList * +get_contacts_supporting_blocking (FolksIndividual *individual) +{ + GeeSet *personas; + GeeIterator *iter; + GList *result = NULL; + + personas = folks_individual_get_personas (individual); + + iter = gee_iterable_iterator (GEE_ITERABLE (personas)); + while (gee_iterator_next (iter)) + { + TpfPersona *persona = gee_iterator_get (iter); + TpContact *contact; + TpConnection *conn; + + if (!TPF_IS_PERSONA (persona)) + continue; + + contact = tpf_persona_get_contact (persona); + if (contact == NULL) + continue; + + conn = tp_contact_get_connection (contact); + + if (tp_proxy_has_interface_by_id (conn, + TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING)) + result = g_list_prepend (result, contact); + } + + g_clear_object (&iter); + + return result; +} + +typedef struct +{ + gboolean blocked; + GtkWidget *parent; +} GotAvatarCtx; + +static GotAvatarCtx * +got_avatar_ctx_new (gboolean blocked, + GtkWidget *parent) +{ + GotAvatarCtx *ctx = g_slice_new0 (GotAvatarCtx); + + ctx->blocked = blocked; + ctx->parent = parent != NULL ? g_object_ref (parent) : NULL; + return ctx; +} + +static void +got_avatar_ctx_free (GotAvatarCtx *ctx) +{ + g_clear_object (&ctx->parent); + g_slice_free (GotAvatarCtx, ctx); +} + +static void +got_avatar (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object); + GotAvatarCtx *ctx = user_data; + GdkPixbuf *avatar; + GError *error = NULL; + gboolean abusive = FALSE; + EmpathyIndividualManager *manager; + + avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual, + result, &error); + + if (error != NULL) + { + DEBUG ("Could not get avatar: %s", error->message); + g_error_free (error); + } + + if (ctx->blocked) { + /* confirm the user really wishes to block the contact */ + if (!empathy_block_individual_dialog_show (GTK_WINDOW (ctx->parent), + individual, avatar, &abusive)) + goto out; + } + + manager = empathy_individual_manager_dup_singleton (); + + empathy_individual_manager_set_blocked (manager, individual, + ctx->blocked, abusive); + + g_object_unref (manager); + +out: + g_clear_object (&avatar); + got_avatar_ctx_free (ctx); +} + +static void +empathy_individual_block_menu_item_toggled (GtkCheckMenuItem *item, + FolksIndividual *individual) +{ + GotAvatarCtx *ctx; + gboolean blocked; + GtkWidget *parent; + + /* @item may be destroyed while the async call is running to get the things + * we need from it right now. */ + blocked = gtk_check_menu_item_get_active (item); + + parent = g_object_get_data ( + G_OBJECT (gtk_widget_get_parent (GTK_WIDGET (item))), + "window"); + + ctx = got_avatar_ctx_new (blocked, parent); + + empathy_pixbuf_avatar_from_individual_scaled_async (individual, + 48, 48, NULL, got_avatar, ctx); +} + +static void +update_block_menu_item (GtkWidget *item, + FolksIndividual *individual) +{ + GList *contacts, *l; + gboolean is_blocked = TRUE; + + contacts = get_contacts_supporting_blocking (individual); + + if (contacts == NULL) + is_blocked = FALSE; + + /* Check the menu item if all his personas are blocked */ + for (l = contacts; l != NULL; l = g_list_next (l)) + { + TpContact *contact = l->data; + + if (!tp_contact_is_blocked (contact)) + { + is_blocked = FALSE; + break; + } + } + + g_signal_handlers_block_by_func (item, + empathy_individual_block_menu_item_toggled, individual); + + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), is_blocked); + + g_signal_handlers_unblock_by_func (item, + empathy_individual_block_menu_item_toggled, individual); + + g_list_free (contacts); +} + +static void +contact_blocked_changed_cb (TpContact *contact, + GParamSpec *spec, + GtkWidget *item) +{ + FolksIndividual *individual; + + individual = g_object_get_data (G_OBJECT (item), "individual"); + + update_block_menu_item (item, individual); +} + +static GtkWidget * +empathy_individiual_block_menu_item_new (FolksIndividual *individual) +{ + GtkWidget *item; + GList *contacts, *l; + + contacts = get_contacts_supporting_blocking (individual); + + /* Can't block, no persona supports blocking */ + if (contacts == NULL) + return NULL; + + item = gtk_check_menu_item_new_with_mnemonic (_("_Block Contact")); + + g_object_set_data_full (G_OBJECT (item), "individual", + g_object_ref (individual), g_object_unref); + + for (l = contacts; l != NULL; l = g_list_next (l)) + { + TpContact *contact = l->data; + + tp_g_signal_connect_object (contact, "notify::is-blocked", + G_CALLBACK (contact_blocked_changed_cb), item, 0); + } + + g_signal_connect (item, "toggled", + G_CALLBACK (empathy_individual_block_menu_item_toggled), individual); + + update_block_menu_item (item, individual); + + g_list_free (contacts); + + return item; +} + +enum +{ + REMOVE_DIALOG_RESPONSE_CANCEL = 0, + REMOVE_DIALOG_RESPONSE_DELETE, + REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK, + REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP +}; + +static int +remove_dialog_show (const gchar *message, + const gchar *secondary_text, + gboolean show_remove_from_group, + gboolean block_button, + GdkPixbuf *avatar, + const gchar *active_group) +{ + GtkWidget *dialog; + gboolean res; + + dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, + GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", message); + + if (avatar != NULL) + { + GtkWidget *image = gtk_image_new_from_pixbuf (avatar); + gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image); + gtk_widget_show (image); + } + + if (show_remove_from_group) + { + GtkWidget *button; + gchar *button_text = g_strdup_printf (_("Remove from _Group \'%s\'"), + active_group); + + /* gtk_dialog_add_button() doesn't allow us to pass a string with a + * mnemonic so we have to create the button manually. */ + button = gtk_button_new_with_mnemonic (button_text); + g_free (button_text); + + gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, + REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP); + + gtk_widget_show (button); + } + + if (block_button) + { + GtkWidget *button; + + /* gtk_dialog_add_button() doesn't allow us to pass a string with a + * mnemonic so we have to create the button manually. */ + button = gtk_button_new_with_mnemonic ( + _("Delete and _Block")); + + gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, + REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK); + + gtk_widget_show (button); + } + + gtk_dialog_add_buttons (GTK_DIALOG (dialog), + GTK_STOCK_CANCEL, REMOVE_DIALOG_RESPONSE_CANCEL, + GTK_STOCK_DELETE, REMOVE_DIALOG_RESPONSE_DELETE, NULL); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + "%s", secondary_text); + + gtk_widget_show (dialog); + + res = gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + + return res; +} + +static void +individual_removed_from_group_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GError *error = NULL; + FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object); + + folks_group_details_change_group_finish ( + FOLKS_GROUP_DETAILS (individual), res, &error); + if (error != NULL) + { + DEBUG ("Individual could not be removed from group: %s", + error->message); + g_error_free (error); + } +} + +static void +remove_got_avatar (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + FolksIndividual *individual = FOLKS_INDIVIDUAL (source_object); + EmpathyIndividualMenu *self = EMPATHY_INDIVIDUAL_MENU (user_data); + EmpathyIndividualMenuPriv *priv = GET_PRIV (self); + GdkPixbuf *avatar; + EmpathyIndividualManager *manager; + gchar *text; + GeeSet *personas; + guint persona_count = 0; + gboolean can_block; + GError *error = NULL; + gint res; + gboolean show_remove_from_group; + GeeSet *groups; + + avatar = empathy_pixbuf_avatar_from_individual_scaled_finish (individual, + result, &error); + + if (error != NULL) + { + DEBUG ("Could not get avatar: %s", error->message); + g_error_free (error); + } + + /* We couldn't retrieve the avatar, but that isn't a fatal error, + * so we still display the remove dialog. */ + + groups = folks_group_details_get_groups (FOLKS_GROUP_DETAILS (individual)); + show_remove_from_group = + gee_collection_get_size (GEE_COLLECTION (groups)) > 1; + + personas = folks_individual_get_personas (individual); + + persona_count = gee_collection_get_size (GEE_COLLECTION (personas)); + + /* If we have more than one TpfPersona, display a different message + * ensuring the user knows that *all* of the meta-contacts' personas will + * be removed. */ + + if (persona_count < 2) + { + /* Not a meta-contact */ + text = + g_strdup_printf ( + _("Do you really want to remove the contact '%s'?"), + folks_alias_details_get_alias ( + FOLKS_ALIAS_DETAILS (individual))); + } + else + { + /* Meta-contact */ + text = + g_strdup_printf ( + _("Do you really want to remove the linked contact '%s'? " + "Note that this will remove all the contacts which make up " + "this linked contact."), + folks_alias_details_get_alias ( + FOLKS_ALIAS_DETAILS (individual))); + } + + + manager = empathy_individual_manager_dup_singleton (); + can_block = empathy_individual_manager_supports_blocking (manager, + individual); + res = remove_dialog_show (_("Removing contact"), text, + show_remove_from_group, can_block, avatar, priv->active_group); + + if (res == REMOVE_DIALOG_RESPONSE_REMOVE_FROM_GROUP) + { + folks_group_details_change_group (FOLKS_GROUP_DETAILS (individual), + priv->active_group, false, individual_removed_from_group_cb, NULL); + goto finally; + } + + if (res == REMOVE_DIALOG_RESPONSE_DELETE || + res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK) + { + gboolean abusive; + + if (res == REMOVE_DIALOG_RESPONSE_DELETE_AND_BLOCK) + { + if (!empathy_block_individual_dialog_show (NULL, individual, + avatar, &abusive)) + goto finally; + + empathy_individual_manager_set_blocked (manager, individual, + TRUE, abusive); + } + + empathy_individual_manager_remove (manager, individual, ""); + } + + finally: + g_free (text); + g_object_unref (manager); + g_object_unref (self); +} + +static void +remove_activate_cb (GtkMenuItem *menuitem, + EmpathyIndividualMenu *self) +{ + EmpathyIndividualMenuPriv *priv = GET_PRIV (self); + + empathy_pixbuf_avatar_from_individual_scaled_async (priv->individual, + 48, 48, NULL, remove_got_avatar, g_object_ref (self)); +} + +static GtkWidget * +empathy_individiual_remove_menu_item_new (EmpathyIndividualMenu *self) +{ + GeeSet *personas; + GeeIterator *iter; + gboolean can_remove = FALSE; + GtkWidget *item, *image; + EmpathyIndividualMenuPriv *priv = GET_PRIV (self); + + /* If any of the Individual's personas can be removed, add an option to + * remove. This will act as a best-effort option. If any Personas cannot be + * removed from the server, then this option will just be inactive upon + * subsequent menu openings */ + personas = folks_individual_get_personas (priv->individual); + iter = gee_iterable_iterator (GEE_ITERABLE (personas)); + while (!can_remove && gee_iterator_next (iter)) + { + FolksPersona *persona = gee_iterator_get (iter); + FolksPersonaStore *store = folks_persona_get_store (persona); + FolksMaybeBool maybe_can_remove = + folks_persona_store_get_can_remove_personas (store); + + if (maybe_can_remove == FOLKS_MAYBE_BOOL_TRUE) + can_remove = TRUE; + + g_clear_object (&persona); + } + g_clear_object (&iter); + + if (!can_remove) + return NULL; + + item = gtk_image_menu_item_new_with_mnemonic (_("_Remove")); + image = gtk_image_new_from_icon_name (GTK_STOCK_REMOVE, + GTK_ICON_SIZE_MENU); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); + + g_signal_connect (item, "activate", + G_CALLBACK (remove_activate_cb), self); + + return item; } static void constructed (GObject *object) { - EmpathyIndividualMenu *self = (EmpathyIndividualMenu *) object; + EmpathyIndividualMenu *self = EMPATHY_INDIVIDUAL_MENU (object); EmpathyIndividualMenuPriv *priv = GET_PRIV (object); GtkMenuShell *shell; GtkWidget *item; @@ -454,10 +959,21 @@ constructed (GObject *object) individual = priv->individual; features = priv->features; + /* Add contact */ + if (features & EMPATHY_INDIVIDUAL_FEATURE_ADD_CONTACT) + { + item = empathy_individual_add_menu_item_new (self, individual); + if (item != NULL) + { + gtk_menu_shell_append (GTK_MENU_SHELL (shell), item); + gtk_widget_show (item); + } + } + /* Chat */ if (features & EMPATHY_INDIVIDUAL_FEATURE_CHAT) { - item = empathy_individual_chat_menu_item_new (individual, NULL); + item = empathy_individual_chat_menu_item_new (self, individual); if (item != NULL) { gtk_menu_shell_append (shell, item); @@ -468,7 +984,7 @@ constructed (GObject *object) /* SMS */ if (features & EMPATHY_INDIVIDUAL_FEATURE_SMS) { - item = empathy_individual_sms_menu_item_new (individual, NULL); + item = empathy_individual_sms_menu_item_new (self, individual); if (item != NULL) { gtk_menu_shell_append (shell, item); @@ -479,12 +995,12 @@ constructed (GObject *object) if (features & EMPATHY_INDIVIDUAL_FEATURE_CALL) { /* Audio Call */ - item = empathy_individual_audio_call_menu_item_new (individual, NULL); + item = empathy_individual_audio_call_menu_item_new (self, individual); gtk_menu_shell_append (shell, item); gtk_widget_show (item); /* Video Call */ - item = empathy_individual_video_call_menu_item_new (individual, NULL); + item = empathy_individual_video_call_menu_item_new (self, individual); gtk_menu_shell_append (shell, item); gtk_widget_show (item); } @@ -498,25 +1014,28 @@ constructed (GObject *object) gtk_widget_show (item); /* File transfer */ - item = empathy_individual_file_transfer_menu_item_new (individual, NULL); - gtk_menu_shell_append (shell, item); - gtk_widget_show (item); + if (features & EMPATHY_INDIVIDUAL_FEATURE_FILE_TRANSFER) + { + item = empathy_individual_file_transfer_menu_item_new (self, individual); + gtk_menu_shell_append (shell, item); + gtk_widget_show (item); + } /* Share my desktop */ /* FIXME we should add the "Share my desktop" menu item if Vino is a registered handler in MC5 */ - item = empathy_individual_share_my_desktop_menu_item_new (individual, NULL); + item = empathy_individual_share_my_desktop_menu_item_new (self, individual); gtk_menu_shell_append (shell, item); gtk_widget_show (item); /* Menu items to target specific contacts */ - individual_menu_add_personas (GTK_MENU_SHELL (object), individual, features); + individual_menu_add_personas (self, GTK_MENU_SHELL (object), + individual, features); /* Separator */ if (features & (EMPATHY_INDIVIDUAL_FEATURE_EDIT | EMPATHY_INDIVIDUAL_FEATURE_INFO | - EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE | - EMPATHY_INDIVIDUAL_FEATURE_LINK)) + EMPATHY_INDIVIDUAL_FEATURE_FAVOURITE)) { item = gtk_separator_menu_item_new (); gtk_menu_shell_append (shell, item); @@ -531,22 +1050,10 @@ constructed (GObject *object) gtk_widget_show (item); } - /* Link */ - if (features & EMPATHY_INDIVIDUAL_FEATURE_LINK) - { - item = empathy_individual_link_menu_item_new (individual); - gtk_menu_shell_append (shell, item); - - g_signal_connect_swapped (item, "activate", - (GCallback) individual_link_menu_item_activate_cb, object); - - gtk_widget_show (item); - } - /* Log */ if (features & EMPATHY_INDIVIDUAL_FEATURE_LOG) { - item = empathy_individual_log_menu_item_new (individual, NULL); + item = empathy_individual_log_menu_item_new (individual); gtk_menu_shell_append (shell, item); gtk_widget_show (item); } @@ -566,6 +1073,32 @@ constructed (GObject *object) gtk_menu_shell_append (shell, item); gtk_widget_show (item); } + + /* Separator & Block */ + if (features & EMPATHY_INDIVIDUAL_FEATURE_BLOCK && + (item = empathy_individiual_block_menu_item_new (individual)) != NULL) { + GtkWidget *sep; + + sep = gtk_separator_menu_item_new (); + gtk_menu_shell_append (shell, sep); + gtk_widget_show (sep); + + gtk_menu_shell_append (shell, item); + gtk_widget_show (item); + } + + /* Separator & Remove */ + if (features & EMPATHY_INDIVIDUAL_FEATURE_REMOVE && + (item = empathy_individiual_remove_menu_item_new (self)) != NULL) { + GtkWidget *sep; + + sep = gtk_separator_menu_item_new (); + gtk_menu_shell_append (shell, sep); + gtk_widget_show (sep); + + gtk_menu_shell_append (shell, item); + gtk_widget_show (item); + } } static void @@ -580,12 +1113,18 @@ get_property (GObject *object, switch (param_id) { + case PROP_ACTIVE_GROUP: + g_value_set_string (value, priv->active_group); + break; case PROP_INDIVIDUAL: g_value_set_object (value, priv->individual); break; case PROP_FEATURES: g_value_set_flags (value, priv->features); break; + case PROP_STORE: + g_value_set_object (value, priv->store); + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; @@ -604,12 +1143,19 @@ set_property (GObject *object, switch (param_id) { + case PROP_ACTIVE_GROUP: + g_assert (priv->active_group == NULL); /* construct only */ + priv->active_group = g_value_dup_string (value); + break; case PROP_INDIVIDUAL: priv->individual = g_value_dup_object (value); break; case PROP_FEATURES: priv->features = g_value_get_flags (value); break; + case PROP_STORE: + priv->store = g_value_dup_object (value); /* read only */ + break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; @@ -622,10 +1168,21 @@ dispose (GObject *object) EmpathyIndividualMenuPriv *priv = GET_PRIV (object); tp_clear_object (&priv->individual); + tp_clear_object (&priv->store); G_OBJECT_CLASS (empathy_individual_menu_parent_class)->dispose (object); } +static void +finalize (GObject *object) +{ + EmpathyIndividualMenuPriv *priv = GET_PRIV (object); + + g_free (priv->active_group); + + G_OBJECT_CLASS (empathy_individual_menu_parent_class)->finalize (object); +} + static void empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass) { @@ -635,6 +1192,19 @@ empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass) object_class->get_property = get_property; object_class->set_property = set_property; object_class->dispose = dispose; + object_class->finalize = finalize; + + /** + * gchar *:active-group: + * + * The group the selected roster-contact widget belongs, or NULL. + */ + g_object_class_install_property (object_class, PROP_ACTIVE_GROUP, + g_param_spec_string ("active-group", + "Active group", + "The group the selected roster-contact widget belongs, or NULL", + NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); /** * EmpathyIndividualMenu:individual: @@ -661,25 +1231,42 @@ empathy_individual_menu_class_init (EmpathyIndividualMenuClass *klass) EMPATHY_INDIVIDUAL_FEATURE_NONE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); - signals[SIGNAL_LINK_CONTACTS_ACTIVATED] = - g_signal_new ("link-contacts-activated", G_OBJECT_CLASS_TYPE (klass), - G_SIGNAL_RUN_LAST, 0, NULL, NULL, + g_object_class_install_property (object_class, PROP_STORE, + g_param_spec_object ("store", + "Store", + "The EmpathyIndividualStore to use to get contact owner", + EMPATHY_TYPE_INDIVIDUAL_STORE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); + + signals[MENU_ITEM_ACTIVATED] = + g_signal_new ("menu-item-activated", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, g_cclosure_marshal_generic, - G_TYPE_NONE, 1, EMPATHY_TYPE_LINKING_DIALOG); + G_TYPE_NONE, + 0); g_type_class_add_private (object_class, sizeof (EmpathyIndividualMenuPriv)); } GtkWidget * empathy_individual_menu_new (FolksIndividual *individual, - EmpathyIndividualFeatureFlags features) + const gchar *active_group, + EmpathyIndividualFeatureFlags features, + EmpathyIndividualStore *store) { g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); + g_return_val_if_fail (store == NULL || + EMPATHY_IS_INDIVIDUAL_STORE (store), NULL); g_return_val_if_fail (features != EMPATHY_INDIVIDUAL_FEATURE_NONE, NULL); return g_object_new (EMPATHY_TYPE_INDIVIDUAL_MENU, + "active-group", active_group, "individual", individual, "features", features, + "store", store, NULL); } @@ -734,6 +1321,16 @@ menu_item_set_first_contact (GtkWidget *item, return item; } +static void +emit_menu_item_activated (GtkMenuItem *item) +{ + EmpathyIndividualMenu *self; + + self = EMPATHY_INDIVIDUAL_MENU (g_object_get_data (G_OBJECT (item), + "individual-menu")); + g_signal_emit (self, signals [MENU_ITEM_ACTIVATED], 0); +} + static void empathy_individual_chat_menu_item_activated (GtkMenuItem *item, EmpathyContact *contact) @@ -741,19 +1338,19 @@ empathy_individual_chat_menu_item_activated (GtkMenuItem *item, g_return_if_fail (EMPATHY_IS_CONTACT (contact)); empathy_chat_with_contact (contact, empathy_get_current_action_time ()); + + emit_menu_item_activated (item); } -GtkWidget * -empathy_individual_chat_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +static GtkWidget * +empathy_individual_chat_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) && - empathy_folks_individual_contains_contact (individual)) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) && + empathy_folks_individual_contains_contact (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (_("_Chat")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_MESSAGE, @@ -761,18 +1358,10 @@ empathy_individual_chat_menu_item_new (FolksIndividual *individual, gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_chat_menu_item_activated), - EMPATHY_ACTION_CHAT); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_chat_menu_item_activated), - EMPATHY_ACTION_CHAT); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_chat_menu_item_activated), + EMPATHY_ACTION_CHAT); return item; } @@ -788,19 +1377,19 @@ empathy_individual_sms_menu_item_activated (GtkMenuItem *item, empathy_contact_get_id (contact), empathy_get_current_action_time (), NULL, NULL); + + emit_menu_item_activated (item); } -GtkWidget * -empathy_individual_sms_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +static GtkWidget * +empathy_individual_sms_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail ((FOLKS_IS_INDIVIDUAL (individual) && - empathy_folks_individual_contains_contact (individual)) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) && + empathy_folks_individual_contains_contact (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (_("_SMS")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_SMS, @@ -808,18 +1397,10 @@ empathy_individual_sms_menu_item_new (FolksIndividual *individual, gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_sms_menu_item_activated), - EMPATHY_ACTION_SMS); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_sms_menu_item_activated), - EMPATHY_ACTION_SMS); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_sms_menu_item_activated), + EMPATHY_ACTION_SMS); return item; } @@ -834,36 +1415,28 @@ empathy_individual_audio_call_menu_item_activated (GtkMenuItem *item, empathy_contact_get_account (contact), TRUE, FALSE, empathy_get_current_action_time ()); + + emit_menu_item_activated (item); } GtkWidget * -empathy_individual_audio_call_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +empathy_individual_audio_call_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Audio Call")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VOIP, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_audio_call_menu_item_activated), - EMPATHY_ACTION_AUDIO_CALL); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_audio_call_menu_item_activated), - EMPATHY_ACTION_AUDIO_CALL); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_audio_call_menu_item_activated), + EMPATHY_ACTION_AUDIO_CALL); return item; } @@ -878,19 +1451,19 @@ empathy_individual_video_call_menu_item_activated (GtkMenuItem *item, empathy_contact_get_account (contact), TRUE, TRUE, empathy_get_current_action_time ()); + + emit_menu_item_activated (item); } GtkWidget * -empathy_individual_video_call_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +empathy_individual_video_call_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - EmpathyCameraMonitor *monitor; + TpawCameraMonitor *monitor; - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (C_("menu item", "_Video Call")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_VIDEO_CALL, @@ -898,23 +1471,15 @@ empathy_individual_video_call_menu_item_new (FolksIndividual *individual, gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_video_call_menu_item_activated), - EMPATHY_ACTION_VIDEO_CALL); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_video_call_menu_item_activated), - EMPATHY_ACTION_VIDEO_CALL); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_video_call_menu_item_activated), + EMPATHY_ACTION_VIDEO_CALL); /* Only follow available cameras if the contact can do Video calls */ if (gtk_widget_get_sensitive (item)) { - monitor = empathy_camera_monitor_dup_singleton (); + monitor = tpaw_camera_monitor_dup_singleton (); g_object_set_data_full (G_OBJECT (item), "monitor", monitor, g_object_unref); g_object_bind_property (monitor, "available", item, "sensitive", @@ -934,34 +1499,22 @@ empathy_individual_log_menu_item_activated (GtkMenuItem *item, empathy_contact_get_id (contact), FALSE, NULL); } -GtkWidget * -empathy_individual_log_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +static GtkWidget * +empathy_individual_log_menu_item_new (FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (_("_Previous Conversations")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_LOG, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_log_menu_item_activated), - EMPATHY_ACTION_VIEW_LOGS); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_log_menu_item_activated), - EMPATHY_ACTION_VIEW_LOGS); - } + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_log_menu_item_activated), + EMPATHY_ACTION_VIEW_LOGS); return item; } @@ -973,18 +1526,18 @@ empathy_individual_file_transfer_menu_item_activated (GtkMenuItem *item, g_return_if_fail (EMPATHY_IS_CONTACT (contact)); empathy_send_file_with_file_chooser (contact); + + emit_menu_item_activated (item); } -GtkWidget * -empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +static GtkWidget * +empathy_individual_file_transfer_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (_("Send File")); image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_DOCUMENT_SEND, @@ -992,18 +1545,10 @@ empathy_individual_file_transfer_menu_item_new (FolksIndividual *individual, gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_file_transfer_menu_item_activated), - EMPATHY_ACTION_SEND_FILE); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_file_transfer_menu_item_activated), - EMPATHY_ACTION_SEND_FILE); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_file_transfer_menu_item_activated), + EMPATHY_ACTION_SEND_FILE); return item; } @@ -1015,36 +1560,28 @@ empathy_individual_share_my_desktop_menu_item_activated (GtkMenuItem *item, g_return_if_fail (EMPATHY_IS_CONTACT (contact)); empathy_share_my_desktop_share_with_contact (contact); + + emit_menu_item_activated (item); } -GtkWidget * -empathy_individual_share_my_desktop_menu_item_new (FolksIndividual *individual, - EmpathyContact *contact) +static GtkWidget * +empathy_individual_share_my_desktop_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) { GtkWidget *item; GtkWidget *image; - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual) || - EMPATHY_IS_CONTACT (contact), - NULL); + g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); item = gtk_image_menu_item_new_with_mnemonic (_("Share My Desktop")); image = gtk_image_new_from_icon_name (GTK_STOCK_NETWORK, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - if (contact != NULL) - { - menu_item_set_contact (item, contact, - G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated), - EMPATHY_ACTION_SHARE_MY_DESKTOP); - } - else - { - menu_item_set_first_contact (item, individual, - G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated), - EMPATHY_ACTION_SHARE_MY_DESKTOP); - } + g_object_set_data (G_OBJECT (item), "individual-menu", self); + menu_item_set_first_contact (item, individual, + G_CALLBACK (empathy_individual_share_my_desktop_menu_item_activated), + EMPATHY_ACTION_SHARE_MY_DESKTOP); return item; } @@ -1058,7 +1595,7 @@ favourite_menu_item_toggled_cb (GtkCheckMenuItem *item, gtk_check_menu_item_get_active (item)); } -GtkWidget * +static GtkWidget * empathy_individual_favourite_menu_item_new (FolksIndividual *individual) { GtkWidget *item; @@ -1076,12 +1613,13 @@ empathy_individual_favourite_menu_item_new (FolksIndividual *individual) } static void -individual_info_menu_item_activate_cb (FolksIndividual *individual) +individual_info_menu_item_activate_cb (GtkMenuItem *item, + FolksIndividual *individual) { - empathy_individual_information_dialog_show (individual, NULL); + empathy_display_individual_info (individual); } -GtkWidget * +static GtkWidget * empathy_individual_info_menu_item_new (FolksIndividual *individual) { GtkWidget *item; @@ -1097,7 +1635,7 @@ empathy_individual_info_menu_item_new (FolksIndividual *individual) gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); gtk_widget_show (image); - g_signal_connect_swapped (item, "activate", + g_signal_connect (item, "activate", G_CALLBACK (individual_info_menu_item_activate_cb), individual); @@ -1110,7 +1648,7 @@ individual_edit_menu_item_activate_cb (FolksIndividual *individual) empathy_individual_edit_dialog_show (individual, NULL); } -GtkWidget * +static GtkWidget * empathy_individual_edit_menu_item_new (FolksIndividual *individual) { EmpathyIndividualManager *manager; @@ -1155,31 +1693,6 @@ empathy_individual_edit_menu_item_new (FolksIndividual *individual) return item; } -GtkWidget * -empathy_individual_link_menu_item_new (FolksIndividual *individual) -{ - GtkWidget *item; - /*GtkWidget *image;*/ - - g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL); - - item = gtk_image_menu_item_new_with_mnemonic ( - /* Translators: this is a verb meaning "to connect two contacts together - * to form a meta-contact". */ - C_("Link individual (contextual menu)", "_Link Contacts…")); - /* TODO */ - /*image = gtk_image_new_from_icon_name (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU); - gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); - gtk_widget_show (image);*/ - - /* Only allow trusted Individuals to be linked */ - gtk_widget_set_sensitive (item, - folks_individual_get_trust_level (individual) == - FOLKS_TRUST_LEVEL_PERSONAS); - - return item; -} - typedef struct { FolksIndividual *individual; @@ -1281,8 +1794,7 @@ room_sub_menu_activate_cb (GtkWidget *item, g_return_if_fail (EMPATHY_IS_CONTACT (contact)); /* send invitation */ - empathy_contact_list_add (EMPATHY_CONTACT_LIST (chat), - contact, _("Inviting you to this room")); + empathy_tp_chat_add (chat, contact, _("Inviting you to this room")); out: g_object_unref (contact); @@ -1305,7 +1817,7 @@ create_room_sub_menu (FolksIndividual *individual, return item; } -GtkWidget * +static GtkWidget * empathy_individual_invite_menu_item_new (FolksIndividual *individual, EmpathyContact *contact) { @@ -1420,10 +1932,117 @@ empathy_individual_invite_menu_item_new (FolksIndividual *individual, gtk_widget_show (image); - g_hash_table_destroy (name_room_map); + g_hash_table_unref (name_room_map); g_object_unref (mgr); g_list_free (names); g_list_free (rooms); return item; } + +static void +add_menu_item_activated (GtkMenuItem *item, + TpContact *tp_contact) +{ + GtkWidget *toplevel; + FolksIndividual *individual; + + toplevel = gtk_widget_get_toplevel (GTK_WIDGET (item)); + if (!gtk_widget_is_toplevel (toplevel) || !GTK_IS_WINDOW (toplevel)) + toplevel = NULL; + + individual = empathy_ensure_individual_from_tp_contact (tp_contact); + + empathy_new_individual_dialog_show_with_individual (GTK_WINDOW (toplevel), + individual); + + g_object_unref (individual); +} + +static GtkWidget * +empathy_individual_add_menu_item_new (EmpathyIndividualMenu *self, + FolksIndividual *individual) +{ + EmpathyIndividualMenuPriv *priv = GET_PRIV (self); + GtkWidget *item, *image; + GeeSet *personas; + GeeIterator *iter; + TpContact *to_add = NULL; + + /* find the first of this Individual's personas which are not in our contact + * list. */ + personas = folks_individual_get_personas (individual); + iter = gee_iterable_iterator (GEE_ITERABLE (personas)); + while (gee_iterator_next (iter)) + { + TpfPersona *persona = gee_iterator_get (iter); + TpContact *contact; + TpConnection *conn; + + if (!TPF_IS_PERSONA (persona)) + goto next; + + contact = tpf_persona_get_contact (persona); + if (contact == NULL) + goto next; + + /* be sure to use a not channel specific contact. + * TODO: Ideally tp-glib should do this for us (fdo #42702)*/ + if (EMPATHY_IS_INDIVIDUAL_STORE_CHANNEL (priv->store)) + { + TpChannel *channel; + TpChannelGroupFlags flags; + + channel = empathy_individual_store_channel_get_channel ( + EMPATHY_INDIVIDUAL_STORE_CHANNEL (priv->store)); + + flags = tp_channel_group_get_flags (channel); + if ((flags & TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES) != 0) + { + /* Channel uses channel specific handles (thanks XMPP...) */ + contact = tp_channel_group_get_contact_owner (channel, contact); + + /* If we don't know the owner, we can't add the contact */ + if (contact == NULL) + goto next; + } + } + + conn = tp_contact_get_connection (contact); + if (conn == NULL) + goto next; + + /* No point to try adding a contact if the CM doesn't support it */ + if (!tp_connection_get_can_change_contact_list (conn)) + goto next; + + /* Can't add ourself */ + if (tp_connection_get_self_contact (conn) == contact) + goto next; + + if (tp_contact_get_subscribe_state (contact) == TP_SUBSCRIPTION_STATE_YES) + goto next; + + g_object_unref (persona); + to_add = contact; + break; + +next: + g_object_unref (persona); + } + + g_object_unref (iter); + + if (to_add == NULL) + return NULL; + + item = gtk_image_menu_item_new_with_mnemonic (_("_Add Contact…")); + image = gtk_image_new_from_icon_name (GTK_STOCK_ADD, GTK_ICON_SIZE_MENU); + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image); + + g_signal_connect_data (item, "activate", + G_CALLBACK (add_menu_item_activated), + g_object_ref (to_add), (GClosureNotify) g_object_unref, 0); + + return item; +}