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);
}
