static void empathy_contact_manager_init (EmpathyContactManager *manager) { GList *connections, *l; EmpathyContactManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (manager, EMPATHY_TYPE_CONTACT_MANAGER, EmpathyContactManagerPriv); manager->priv = priv; priv->lists = g_hash_table_new_full (empathy_proxy_hash, empathy_proxy_equal, (GDestroyNotify) g_object_unref, (GDestroyNotify) g_object_unref); priv->account_manager = empathy_account_manager_dup_singleton (); priv->contact_monitor = NULL; g_signal_connect (priv->account_manager, "new-connection", G_CALLBACK (contact_manager_new_connection_cb), manager); /* Get ContactList for existing connections */ connections = empathy_account_manager_dup_connections (priv->account_manager); for (l = connections; l; l = l->next) { contact_manager_new_connection_cb (priv->account_manager, l->data, manager); g_object_unref (l->data); } g_list_free (connections); }
static void empathy_account_chooser_init (EmpathyAccountChooser *chooser) { EmpathyAccountChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser, EMPATHY_TYPE_ACCOUNT_CHOOSER, EmpathyAccountChooserPriv); chooser->priv = priv; priv->set_active_item = FALSE; priv->filter = NULL; priv->filter_data = NULL; priv->manager = empathy_account_manager_dup_singleton (); g_signal_connect (priv->manager, "account-created", G_CALLBACK (account_chooser_account_created_cb), chooser); g_signal_connect (priv->manager, "account-deleted", G_CALLBACK (account_chooser_account_deleted_cb), chooser); g_signal_connect (priv->manager, "account-connection-changed", G_CALLBACK (account_chooser_connection_changed_cb), chooser); account_chooser_setup (EMPATHY_ACCOUNT_CHOOSER (chooser)); }
EmpathyAccount * get_test_account (void) { McProfile *profile; EmpathyAccountManager *account_manager; EmpathyAccount *account; GList *accounts; account_manager = empathy_account_manager_dup_singleton (); profile = mc_profile_lookup ("test"); accounts = mc_accounts_list_by_profile (profile); if (g_list_length (accounts) == 0) { /* need to create a test account */ account = empathy_account_manager_create_by_profile (account_manager, profile); } else { /* reuse an existing test account */ McAccount *mc_account; mc_account = accounts->data; account = empathy_account_manager_lookup (account_manager, mc_account_get_unique_name (mc_account)); } g_object_unref (account_manager); g_object_unref (profile); return account; }
END_TEST START_TEST (test_empathy_chatroom_manager_remove) { EmpathyChatroomManager *mgr; gchar *file; EmpathyAccount *account; struct chatroom_t chatrooms[] = { { "name2", "room2", FALSE, TRUE }}; EmpathyChatroom *chatroom; EmpathyAccountManager *account_mgr; account_mgr = empathy_account_manager_dup_singleton (); account = get_test_account (); copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE); file = get_user_xml_file (CHATROOM_FILE); /* change the chatrooms XML file to use the account we just created */ fail_unless (change_account_name_in_file (account, file)); mgr = empathy_chatroom_manager_dup_singleton (file); /* remove room1 */ chatroom = empathy_chatroom_manager_find (mgr, account, "room1"); fail_if (chatroom == NULL); empathy_chatroom_manager_remove (mgr, chatroom); check_chatrooms_list (mgr, account, chatrooms, 1); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); check_chatrooms_list (mgr, account, chatrooms, 1); /* remove room1 */ chatroom = empathy_chatroom_manager_find (mgr, account, "room2"); fail_if (chatroom == NULL); empathy_chatroom_manager_remove (mgr, chatroom); check_chatrooms_list (mgr, account, chatrooms, 0); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); check_chatrooms_list (mgr, account, chatrooms, 0); g_object_unref (mgr); g_free (file); g_object_unref (account); g_object_unref (account_mgr); }
static void empathy_status_icon_init (EmpathyStatusIcon *icon) { EmpathyStatusIconPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (icon, EMPATHY_TYPE_STATUS_ICON, EmpathyStatusIconPriv); icon->priv = priv; priv->icon = gtk_status_icon_new (); priv->account_manager = empathy_account_manager_dup_singleton (); priv->idle = empathy_idle_dup_singleton (); priv->event_manager = empathy_event_manager_dup_singleton (); g_signal_connect (priv->account_manager, "account-connection-changed", G_CALLBACK (status_icon_connection_changed_cb), icon); /* make icon listen and respond to MAIN_WINDOW_HIDDEN changes */ empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_UI_MAIN_WINDOW_HIDDEN, status_icon_notify_visibility_cb, icon); #ifdef HAVE_LIBINDICATE empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_UI_USE_LIBINDICATE, status_icon_notify_libindicate_cb, icon); #endif status_icon_create_menu (icon); status_icon_idle_notify_cb (icon); g_signal_connect_swapped (priv->idle, "notify", G_CALLBACK (status_icon_idle_notify_cb), icon); g_signal_connect (priv->event_manager, "event-added", G_CALLBACK (status_icon_event_added_cb), icon); g_signal_connect (priv->event_manager, "event-removed", G_CALLBACK (status_icon_event_removed_cb), icon); g_signal_connect (priv->event_manager, "event-updated", G_CALLBACK (status_icon_event_updated_cb), icon); g_signal_connect (priv->icon, "activate", G_CALLBACK (status_icon_activate_cb), icon); g_signal_connect (priv->icon, "popup-menu", G_CALLBACK (status_icon_popup_menu_cb), icon); }
static GObject * empathy_chatroom_manager_constructor (GType type, guint n_props, GObjectConstructParam *props) { GObject *obj; EmpathyChatroomManager *self; EmpathyChatroomManagerPriv *priv; if (chatroom_manager_singleton != NULL) return g_object_ref (chatroom_manager_singleton); /* Parent constructor chain */ obj = G_OBJECT_CLASS (empathy_chatroom_manager_parent_class)-> constructor (type, n_props, props); self = EMPATHY_CHATROOM_MANAGER (obj); priv = GET_PRIV (self); priv->ready = FALSE; chatroom_manager_singleton = self; g_object_add_weak_pointer (obj, (gpointer) &chatroom_manager_singleton); priv->account_manager = empathy_account_manager_dup_singleton (); priv->account_manager_ready_handler_id = 0; if (empathy_account_manager_is_ready (priv->account_manager)) chatroom_manager_get_all (self); else priv->account_manager_ready_handler_id = g_signal_connect ( G_OBJECT (priv->account_manager), "notify::ready", G_CALLBACK (account_manager_ready_cb), self); if (priv->file == NULL) { /* Set the default file path */ gchar *dir; dir = g_build_filename (g_get_user_config_dir (), PACKAGE_NAME, NULL); if (!g_file_test (dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR); priv->file = g_build_filename (dir, CHATROOMS_XML_FILENAME, NULL); g_free (dir); } return obj; }
static gboolean init (NstPlugin *plugin) { g_print ("Init %s plugin\n", plugin->info->id); empathy_gtk_init (); acc_manager = empathy_account_manager_dup_singleton (); if (empathy_account_manager_is_ready (acc_manager)) handle_account_manager_ready (); else g_signal_connect (acc_manager, "notify::ready", G_CALLBACK (acc_manager_ready_cb), NULL); return TRUE; }
void empathy_account_set_enabled_async (EmpathyAccount *account, gboolean enabled, GAsyncReadyCallback callback, gpointer user_data) { EmpathyAccountPriv *priv = GET_PRIV (account); EmpathyAccountManager *acc_manager; GValue value = {0, }; GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), callback, user_data, empathy_account_set_enabled_finish); char *status = NULL; char *status_message = NULL; TpConnectionPresenceType presence; if (priv->enabled == enabled) { g_simple_async_result_complete_in_idle (result); return; } if (enabled) { acc_manager = empathy_account_manager_dup_singleton (); presence = empathy_account_manager_get_requested_global_presence (acc_manager, &status, &status_message); if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET) empathy_account_request_presence (account, presence, status, status_message); g_object_unref (acc_manager); g_free (status); g_free (status_message); } g_value_init (&value, G_TYPE_BOOLEAN); g_value_set_boolean (&value, enabled); tp_cli_dbus_properties_call_set (TP_PROXY (priv->account), -1, TP_IFACE_ACCOUNT, "Enabled", &value, account_enabled_set_cb, result, NULL, G_OBJECT (account)); }
static void empathy_idle_init (EmpathyIdle *idle) { EmpathyIdlePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (idle, EMPATHY_TYPE_IDLE, EmpathyIdlePriv); idle->priv = priv; priv->is_idle = FALSE; priv->manager = empathy_account_manager_dup_singleton (); if (empathy_account_manager_is_ready (priv->manager)) { priv->state = empathy_account_manager_get_global_presence (priv->manager, NULL, &priv->status); } else { g_signal_connect (priv->manager, "notify::ready", G_CALLBACK (account_manager_ready_cb), idle); } g_signal_connect (priv->manager, "global-presence-changed", G_CALLBACK (idle_presence_changed_cb), idle); priv->gs_proxy = dbus_g_proxy_new_for_name (tp_get_bus (), "org.gnome.SessionManager", "/org/gnome/SessionManager/Presence", "org.gnome.SessionManager.Presence"); if (priv->gs_proxy) { dbus_g_proxy_add_signal (priv->gs_proxy, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->gs_proxy, "StatusChanged", G_CALLBACK (idle_session_status_changed_cb), idle, NULL); } else { DEBUG ("Failed to get gs proxy"); } priv->connectivity = empathy_connectivity_dup_singleton (); priv->state_change_signal_id = g_signal_connect (priv->connectivity, "state-change", G_CALLBACK (idle_state_change_cb), idle); }
GtkWidget * empathy_log_window_show (EmpathyAccount *account, const gchar *chat_id, gboolean is_chatroom, GtkWindow *parent) { static EmpathyLogWindow *window = NULL; EmpathyAccountChooser *account_chooser; EmpathyAccountManager *account_manager; gint account_num; GtkBuilder *gui; gchar *filename; if (window) { gtk_window_present (GTK_WINDOW (window->window)); if (account && chat_id) { gtk_notebook_set_current_page (GTK_NOTEBOOK (window->notebook), 1); log_window_chats_set_selected (window, account, chat_id, is_chatroom); } return window->window; } window = g_new0 (EmpathyLogWindow, 1); window->log_manager = empathy_log_manager_dup_singleton (); filename = empathy_file_lookup ("empathy-log-window.ui", "libempathy-gtk"); gui = empathy_builder_get_file (filename, "log_window", &window->window, "notebook", &window->notebook, "entry_find", &window->entry_find, "button_find", &window->button_find, "treeview_find", &window->treeview_find, "scrolledwindow_find", &window->scrolledwindow_find, "button_previous", &window->button_previous, "button_next", &window->button_next, "entry_chats", &window->entry_chats, "calendar_chats", &window->calendar_chats, "vbox_chats", &window->vbox_chats, "treeview_chats", &window->treeview_chats, "scrolledwindow_chats", &window->scrolledwindow_chats, NULL); g_free (filename); empathy_builder_connect (gui, window, "log_window", "destroy", log_window_destroy_cb, "entry_find", "changed", log_window_entry_find_changed_cb, "button_previous", "clicked", log_window_button_previous_clicked_cb, "button_next", "clicked", log_window_button_next_clicked_cb, "button_find", "clicked", log_window_button_find_clicked_cb, "entry_chats", "changed", log_window_entry_chats_changed_cb, "entry_chats", "activate", log_window_entry_chats_activate_cb, NULL); g_object_unref (gui); g_object_add_weak_pointer (G_OBJECT (window->window), (gpointer) &window); /* We set this up here so we can block it when needed. */ g_signal_connect (window->calendar_chats, "day-selected", G_CALLBACK (log_window_calendar_chats_day_selected_cb), window); g_signal_connect (window->calendar_chats, "month-changed", G_CALLBACK (log_window_calendar_chats_month_changed_cb), window); /* Configure Search EmpathyChatView */ window->chatview_find = empathy_theme_manager_create_view (empathy_theme_manager_get ()); gtk_container_add (GTK_CONTAINER (window->scrolledwindow_find), GTK_WIDGET (window->chatview_find)); gtk_widget_show (GTK_WIDGET (window->chatview_find)); /* Configure Contacts EmpathyChatView */ window->chatview_chats = empathy_theme_manager_create_view (empathy_theme_manager_get ()); gtk_container_add (GTK_CONTAINER (window->scrolledwindow_chats), GTK_WIDGET (window->chatview_chats)); gtk_widget_show (GTK_WIDGET (window->chatview_chats)); /* Account chooser for chats */ window->account_chooser_chats = empathy_account_chooser_new (); account_chooser = EMPATHY_ACCOUNT_CHOOSER (window->account_chooser_chats); gtk_box_pack_start (GTK_BOX (window->vbox_chats), window->account_chooser_chats, FALSE, TRUE, 0); g_signal_connect (window->account_chooser_chats, "changed", G_CALLBACK (log_window_chats_accounts_changed_cb), window); /* Populate */ account_manager = empathy_account_manager_dup_singleton (); account_num = empathy_account_manager_get_count (account_manager); g_object_unref (account_manager); if (account_num > 1) { gtk_widget_show (window->vbox_chats); gtk_widget_show (window->account_chooser_chats); } else { gtk_widget_hide (window->vbox_chats); gtk_widget_hide (window->account_chooser_chats); } /* Search List */ log_window_find_setup (window); /* Contacts */ log_window_chats_setup (window); log_window_chats_populate (window); /* Select chat */ if (account && chat_id) { gtk_notebook_set_current_page (GTK_NOTEBOOK (window->notebook), 1); log_window_chats_set_selected (window, account, chat_id, is_chatroom); } if (parent) { gtk_window_set_transient_for (GTK_WINDOW (window->window), GTK_WINDOW (parent)); } gtk_widget_show (window->window); return window->window; }
END_TEST START_TEST (test_empathy_chatroom_manager_change_chatroom) { EmpathyChatroomManager *mgr; gchar *file; EmpathyAccount *account; EmpathyAccountManager *account_manager; struct chatroom_t chatrooms[] = { { "name1", "room1", TRUE, TRUE }, { "name2", "room2", FALSE, TRUE }}; EmpathyChatroom *chatroom; account_manager = empathy_account_manager_dup_singleton (); account = get_test_account (); copy_xml_file (CHATROOM_SAMPLE, "foo.xml"); file = get_user_xml_file ("foo.xml"); /* change the chatrooms XML file to use the account we just created */ fail_unless (change_account_name_in_file (account, file)); mgr = empathy_chatroom_manager_dup_singleton (file); check_chatrooms_list (mgr, account, chatrooms, 2); /* change room2 name */ chatroom = empathy_chatroom_manager_find (mgr, account, "room2"); fail_if (chatroom == NULL); empathy_chatroom_set_name (chatroom, "new_name"); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); chatrooms[1].name = "new_name"; check_chatrooms_list (mgr, account, chatrooms, 2); /* change room2 auto-connect status */ chatroom = empathy_chatroom_manager_find (mgr, account, "room2"); fail_if (chatroom == NULL); empathy_chatroom_set_auto_connect (chatroom, TRUE); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); chatrooms[1].auto_connect = TRUE; check_chatrooms_list (mgr, account, chatrooms, 2); /* change room2 room */ chatroom = empathy_chatroom_manager_find (mgr, account, "room2"); fail_if (chatroom == NULL); empathy_chatroom_set_room (chatroom, "new_room"); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); chatrooms[1].room = "new_room"; check_chatrooms_list (mgr, account, chatrooms, 2); g_object_unref (mgr); g_free (file); g_object_unref (account); g_object_unref (account_manager); }
END_TEST START_TEST (test_empathy_chatroom_manager_change_favorite) { EmpathyChatroomManager *mgr; gchar *file; EmpathyAccount *account; EmpathyAccountManager *account_manager; struct chatroom_t chatrooms[] = { { "name1", "room1", TRUE, TRUE }, { "name2", "room2", FALSE, FALSE }}; EmpathyChatroom *chatroom; account_manager = empathy_account_manager_dup_singleton (); account = get_test_account (); copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE); file = get_user_xml_file (CHATROOM_FILE); /* change the chatrooms XML file to use the account we just created */ fail_unless (change_account_name_in_file (account, file)); mgr = empathy_chatroom_manager_dup_singleton (file); /* room2 is not favorite anymore */ chatroom = empathy_chatroom_manager_find (mgr, account, "room2"); fail_if (chatroom == NULL); g_object_set (chatroom, "favorite", FALSE, NULL); check_chatrooms_list (mgr, account, chatrooms, 2); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); /* room2 is not present in the XML file anymore as it's not a favorite */ check_chatrooms_list (mgr, account, chatrooms, 1); /* re-add room2 */ chatroom = empathy_chatroom_new_full (account, "room2", "name2", FALSE); empathy_chatroom_manager_add (mgr, chatroom); check_chatrooms_list (mgr, account, chatrooms, 2); /* set room2 as favorite */ g_object_set (chatroom, "favorite", TRUE, NULL); chatrooms[1].favorite = TRUE; check_chatrooms_list (mgr, account, chatrooms, 2); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); /* room2 is back in the XML file now */ check_chatrooms_list (mgr, account, chatrooms, 2); g_object_unref (mgr); g_object_unref (chatroom); g_free (file); g_object_unref (account_manager); g_object_unref (account); }
END_TEST START_TEST (test_empathy_chatroom_manager_add) { EmpathyChatroomManager *mgr; gchar *file; EmpathyAccount *account; EmpathyAccountManager *account_manager; struct chatroom_t chatrooms[] = { { "name1", "room1", TRUE, TRUE }, { "name2", "room2", FALSE, TRUE }, { "name3", "room3", FALSE, TRUE }, { "name4", "room4", FALSE, FALSE }}; EmpathyChatroom *chatroom; account_manager = empathy_account_manager_dup_singleton (); account = get_test_account (); copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE); file = get_user_xml_file (CHATROOM_FILE); /* change the chatrooms XML file to use the account we just created */ fail_unless (change_account_name_in_file (account, file)); mgr = empathy_chatroom_manager_dup_singleton (file); /* add a favorite chatroom */ chatroom = empathy_chatroom_new_full (account, "room3", "name3", FALSE); g_object_set (chatroom, "favorite", TRUE, NULL); empathy_chatroom_manager_add (mgr, chatroom); g_object_unref (chatroom); check_chatrooms_list (mgr, account, chatrooms, 3); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); /* chatroom has been added to the XML file as it's a favorite */ check_chatrooms_list (mgr, account, chatrooms, 3); /* add a non favorite chatroom */ chatroom = empathy_chatroom_new_full (account, "room4", "name4", FALSE); g_object_set (chatroom, "favorite", FALSE, NULL); empathy_chatroom_manager_add (mgr, chatroom); g_object_unref (chatroom); check_chatrooms_list (mgr, account, chatrooms, 4); /* reload chatrooms file */ g_object_unref (mgr); mgr = empathy_chatroom_manager_dup_singleton (file); /* chatrooms has not been added to the XML file */ check_chatrooms_list (mgr, account, chatrooms, 3); g_object_unref (mgr); g_free (file); g_object_unref (account_manager); g_object_unref (account); }
/* Not used for now as there is no API to remove completely gconf keys. * So we reuse existing accounts instead of creating new ones */ void destroy_test_account (EmpathyAccount *account) { GConfClient *client; gchar *path; GError *error = NULL; GSList *entries = NULL, *l; EmpathyAccountManager *manager; client = gconf_client_get_default (); path = g_strdup_printf ("/apps/telepathy/mc/accounts/%s", empathy_account_get_unique_name (account)); entries = gconf_client_all_entries (client, path, &error); if (error != NULL) { g_print ("failed to list entries in %s: %s\n", path, error->message); g_error_free (error); error = NULL; } for (l = entries; l != NULL; l = g_slist_next (l)) { GConfEntry *entry = l->data; if (g_str_has_suffix (entry->key, "data_dir")) { gchar *dir; dir = gconf_client_get_string (client, entry->key, &error); if (error != NULL) { g_print ("get data_dir string failed: %s\n", entry->key); g_error_free (error); error = NULL; } else { if (g_rmdir (dir) != 0) g_print ("can't remove %s\n", dir); } g_free (dir); } /* FIXME: this doesn't remove the key */ gconf_client_unset (client, entry->key, &error); if (error != NULL) { g_print ("unset of %s failed: %s\n", path, error->message); g_error_free (error); error = NULL; } gconf_entry_unref (entry); } g_slist_free (entries); g_object_unref (client); g_free (path); manager = empathy_account_manager_dup_singleton (); empathy_account_manager_remove (manager, account); g_object_unref (account); g_object_unref (manager); }
static void contact_list_view_drag_data_received (GtkWidget *view, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection, guint info, guint time) { EmpathyContactListViewPriv *priv; EmpathyAccountManager *account_manager; EmpathyTpContactFactory *factory = NULL; EmpathyAccount *account; GtkTreeModel *model; GtkTreeViewDropPosition position; GtkTreePath *path; const gchar *id; gchar **strv = NULL; const gchar *account_id; const gchar *contact_id; gchar *new_group = NULL; gchar *old_group = NULL; DndGetContactData *data; gboolean is_row; gboolean success = TRUE; priv = GET_PRIV (view); model = gtk_tree_view_get_model (GTK_TREE_VIEW (view)); /* Get destination group information. */ is_row = gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (view), x, y, &path, &position); if (is_row) { new_group = empathy_contact_list_store_get_parent_group (model, path, NULL); gtk_tree_path_free (path); } /* Get source group information. */ if (priv->drag_row) { path = gtk_tree_row_reference_get_path (priv->drag_row); if (path) { old_group = empathy_contact_list_store_get_parent_group ( model, path, NULL); gtk_tree_path_free (path); } } if (!tp_strdiff (old_group, new_group)) { g_free (new_group); g_free (old_group); goto OUT; } id = (const gchar*) gtk_selection_data_get_data (selection); DEBUG ("Received %s%s drag & drop contact from roster with id:'%s'", context->action == GDK_ACTION_MOVE ? "move" : "", context->action == GDK_ACTION_COPY ? "copy" : "", id); strv = g_strsplit (id, "/", 2); account_id = strv[0]; contact_id = strv[1]; account_manager = empathy_account_manager_dup_singleton (); account = empathy_account_manager_lookup (account_manager, account_id); if (account) { TpConnection *connection; connection = empathy_account_get_connection (account); if (connection) { factory = empathy_tp_contact_factory_dup_singleton (connection); } } g_object_unref (account_manager); if (!factory) { DEBUG ("Failed to get factory for account '%s'", account_id); success = FALSE; g_free (new_group); g_free (old_group); goto OUT; } data = g_slice_new0 (DndGetContactData); data->new_group = new_group; data->old_group = old_group; data->action = context->action; /* FIXME: We should probably wait for the cb before calling * gtk_drag_finish */ empathy_tp_contact_factory_get_from_id (factory, contact_id, contact_list_view_drag_got_contact, data, (GDestroyNotify) contact_list_view_dnd_get_contact_free, G_OBJECT (view)); g_object_unref (factory); OUT: g_strfreev (strv); gtk_drag_finish (context, success, FALSE, GDK_CURRENT_TIME); }