]> git.0d.be Git - empathy.git/commitdiff
Port empathy.c to telepathy-style
authorCosimo Cecchi <cosimo.cecchi@collabora.co.uk>
Sat, 1 Aug 2009 14:54:23 +0000 (16:54 +0200)
committerSjoerd Simons <sjoerd.simons@collabora.co.uk>
Sat, 22 Aug 2009 13:13:11 +0000 (14:13 +0100)
src/empathy.c

index 718fe70bfc7a5324deb5cb53365411d54413b072..b80b64be7aca5f7b9f3b86985c8d960590f5bfd4 100644 (file)
@@ -1,6 +1,5 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
 /*
- * Copyright (C) 2007-2008 Collabora Ltd.
+ * Copyright (C) 2007-2009 Collabora Ltd.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
 
 static void
 dispatch_cb (EmpathyDispatcher *dispatcher,
-            EmpathyDispatchOperation *operation,
-            gpointer           user_data)
+    EmpathyDispatchOperation *operation,
+    gpointer user_data)
 {
-       GQuark channel_type;
-
-       channel_type = empathy_dispatch_operation_get_channel_type_id (operation);
-
-       if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT) {
-               EmpathyTpChat *tp_chat;
-               EmpathyChat   *chat = NULL;
-               const gchar   *id;
-
-               tp_chat = EMPATHY_TP_CHAT (
-                       empathy_dispatch_operation_get_channel_wrapper (operation));
-
-               id = empathy_tp_chat_get_id (tp_chat);
-               if (!id) {
-                       EmpathyContact *contact;
-
-                       contact = empathy_tp_chat_get_remote_contact (tp_chat);
-                       if (contact) {
-                               id = empathy_contact_get_id (contact);
-                       }
-               }
-
-               if (id) {
-                       EmpathyAccountManager *manager;
-                       TpConnection *connection;
-                       EmpathyAccount *account;
-
-                       manager = empathy_account_manager_dup_singleton ();
-                       connection = empathy_tp_chat_get_connection (tp_chat);
-                       account = empathy_account_manager_get_account_for_connection (manager,
-                                                                      connection);
-                       chat = empathy_chat_window_find_chat (account, id);
-                       g_object_unref (manager);
-               }
-
-               if (chat) {
-                       empathy_chat_set_tp_chat (chat, tp_chat);
-               } else {
-                       chat = empathy_chat_new (tp_chat);
-               }
-
-               empathy_chat_window_present_chat (chat);
-
-               empathy_dispatch_operation_claim (operation);
-       } else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA) {
-               EmpathyCallFactory *factory;
-
-               factory = empathy_call_factory_get ();
-               empathy_call_factory_claim_channel (factory, operation);
-       } else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER) {
-               EmpathyFTFactory *factory;
-
-               factory = empathy_ft_factory_dup_singleton ();
-
-               /* if the operation is not incoming, don't claim it,
-                * as it might have been triggered by another client, and
-                * we are observing it.
-                */
-               if (empathy_dispatch_operation_is_incoming (operation)) {
-                       empathy_ft_factory_claim_channel (factory, operation);
-               }
-       }
+  GQuark channel_type;
+
+  channel_type = empathy_dispatch_operation_get_channel_type_id (operation);
+
+  if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
+    {
+      EmpathyTpChat *tp_chat;
+      EmpathyChat   *chat = NULL;
+      const gchar   *id;
+
+      tp_chat = EMPATHY_TP_CHAT
+        (empathy_dispatch_operation_get_channel_wrapper (operation));
+
+      id = empathy_tp_chat_get_id (tp_chat);
+      if (!id)
+        {
+          EmpathyContact *contact;
+
+          contact = empathy_tp_chat_get_remote_contact (tp_chat);
+          if (contact)
+            id = empathy_contact_get_id (contact);
+        }
+
+      if (id)
+        {
+          EmpathyAccountManager *manager;
+          TpConnection *connection;
+          EmpathyAccount *account;
+
+          manager = empathy_account_manager_dup_singleton ();
+          connection = empathy_tp_chat_get_connection (tp_chat);
+          account = empathy_account_manager_get_account_for_connection (manager,
+              connection);
+          chat = empathy_chat_window_find_chat (account, id);
+          g_object_unref (manager);
+        }
+
+      if (chat)
+        empathy_chat_set_tp_chat (chat, tp_chat);
+      else
+        chat = empathy_chat_new (tp_chat);
+
+      empathy_chat_window_present_chat (chat);
+
+      empathy_dispatch_operation_claim (operation);
+    }
+  else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
+    {
+      EmpathyCallFactory *factory;
+
+      factory = empathy_call_factory_get ();
+      empathy_call_factory_claim_channel (factory, operation);
+    }
+  else if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER)
+    {
+      EmpathyFTFactory *factory;
+
+      factory = empathy_ft_factory_dup_singleton ();
+
+      /* if the operation is not incoming, don't claim it,
+       * as it might have been triggered by another client, and
+       * we are observing it.
+       */
+      if (empathy_dispatch_operation_is_incoming (operation))
+        empathy_ft_factory_claim_channel (factory, operation);
+    }
 }
 
 /* Salut account creation */
 static gboolean
 should_create_salut_account (void)
 {
-       EmpathyAccountManager *manager;
-       gboolean salut_created = FALSE;
-       GList *accounts, *l;
+  EmpathyAccountManager *manager;
+  gboolean salut_created = FALSE;
+  GList *accounts, *l;
 
-       /* Check if we already created a salut account */
-       empathy_conf_get_bool (empathy_conf_get (),
-                              EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
-                              &salut_created);
+  /* Check if we already created a salut account */
+  empathy_conf_get_bool (empathy_conf_get (),
+      EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
+      &salut_created);
 
-       if (salut_created)
-               {
-                       DEBUG ("Gconf says we already created a salut account once");
-                       return FALSE;
-               }
+  if (salut_created)
+    {
+      DEBUG ("Gconf says we already created a salut account once");
+      return FALSE;
+    }
 
-       manager = empathy_account_manager_dup_singleton ();
-       accounts = empathy_account_manager_dup_accounts (manager);
+  manager = empathy_account_manager_dup_singleton ();
+  accounts = empathy_account_manager_dup_accounts (manager);
 
-       for (l = accounts; l != NULL;  l = g_list_next (l)) {
-               EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
+  for (l = accounts; l != NULL;  l = g_list_next (l))
+    {
+      EmpathyAccount *account = EMPATHY_ACCOUNT (l->data);
 
-               if (!tp_strdiff (empathy_account_get_protocol (account), "local-xmpp"))
-                       salut_created = TRUE;
+      if (!tp_strdiff (empathy_account_get_protocol (account), "local-xmpp"))
+        salut_created = TRUE;
 
-               g_object_unref (account);
-       }
+      g_object_unref (account);
+    }
 
-       g_object_unref (manager);
+  g_object_unref (manager);
 
-       if (salut_created)
-               {
-                       DEBUG ("Existing salut account already exists, flagging so in gconf");
-                       empathy_conf_set_bool (empathy_conf_get (),
-                               EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
-                               TRUE);
-               }
+  if (salut_created)
+    {
+      DEBUG ("Existing salut account already exists, flagging so in gconf");
+      empathy_conf_set_bool (empathy_conf_get (),
+          EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
+          TRUE);
+    }
 
-       return !salut_created;
+  return !salut_created;
 }
 
 static void
 salut_account_created (GObject *source,
-       GAsyncResult *result, gpointer user_data)
+    GAsyncResult *result,
+    gpointer user_data)
 {
-       EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
-       EmpathyAccount *account;
-       GError *error = NULL;
-
-       if (!empathy_account_settings_apply_finish (settings, result, &error))
-               {
-                       DEBUG ("Failed to create salut account: %s", error->message);
-                       g_error_free (error);
-                       return;
-               }
-
-       account = empathy_account_settings_get_account (settings);
-
-       empathy_account_set_enabled (account, TRUE);
-       empathy_conf_set_bool (empathy_conf_get (),
-                              EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
-                              TRUE);
+  EmpathyAccountSettings *settings = EMPATHY_ACCOUNT_SETTINGS (source);
+  EmpathyAccount *account;
+  GError *error = NULL;
+
+  if (!empathy_account_settings_apply_finish (settings, result, &error))
+    {
+      DEBUG ("Failed to create salut account: %s", error->message);
+      g_error_free (error);
+      return;
+    }
+
+  account = empathy_account_settings_get_account (settings);
+
+  empathy_account_set_enabled (account, TRUE);
+  empathy_conf_set_bool (empathy_conf_get (),
+      EMPATHY_PREFS_SALUT_ACCOUNT_CREATED,
+      TRUE);
 }
 
 static void
 use_conn_notify_cb (EmpathyConf *conf,
-                   const gchar *key,
-                   gpointer     user_data)
+    const gchar *key,
+    gpointer     user_data)
 {
-       EmpathyConnectivity *connectivity = user_data;
-       gboolean     use_conn;
+  EmpathyConnectivity *connectivity = user_data;
+  gboolean     use_conn;
 
-       if (empathy_conf_get_bool (conf, key, &use_conn)) {
-               empathy_connectivity_set_use_conn (connectivity, use_conn);
-       }
+  if (empathy_conf_get_bool (conf, key, &use_conn))
+    {
+      empathy_connectivity_set_use_conn (connectivity, use_conn);
+    }
 }
 
 static void
 create_salut_account_if_needed (EmpathyConnectionManagers *managers)
 {
-       EmpathyAccountSettings  *settings;
-       TpConnectionManager *manager;
-       const TpConnectionManagerProtocol *protocol;
-       EBook      *book;
-       EContact   *contact;
-       gchar      *nickname = NULL;
-       gchar      *first_name = NULL;
-       gchar      *last_name = NULL;
-       gchar      *email = NULL;
-       gchar      *jid = NULL;
-       GError     *error = NULL;
-
-
-       if (!should_create_salut_account ())
-               return;
-
-       manager = empathy_connection_managers_get_cm (managers, "salut");
-       if (manager == NULL)
-               {
-                       DEBUG ("Salut not installed, not making a salut account");
-                       return;
-               }
-
-       protocol = tp_connection_manager_get_protocol (manager, "local-xmpp");
-       if (protocol == NULL)
-               {
-                       DEBUG ("Salut doesn't support local-xmpp!!");
-                       return;
-               }
-
-       DEBUG ("Trying to add a salut account...");
-
-       /* Get self EContact from EDS */
-       if (!e_book_get_self (&contact, &book, &error)) {
-               DEBUG ("Failed to get self econtact: %s",
-                       error ? error->message : "No error given");
-               g_clear_error (&error);
-               return;
-       }
-
-       settings = empathy_account_settings_new ("salut", "local-xmpp",
-               _("People nearby"));
-
-       nickname = e_contact_get (contact, E_CONTACT_NICKNAME);
-       first_name = e_contact_get (contact, E_CONTACT_GIVEN_NAME);
-       last_name = e_contact_get (contact, E_CONTACT_FAMILY_NAME);
-       email = e_contact_get (contact, E_CONTACT_EMAIL_1);
-       jid = e_contact_get (contact, E_CONTACT_IM_JABBER_HOME_1);
-
-       if (!tp_strdiff (nickname, "nickname")) {
-               g_free (nickname);
-               nickname = NULL;
-       }
-
-       DEBUG ("Salut account created:\nnickname=%s\nfirst-name=%s\n"
-               "last-name=%s\nemail=%s\njid=%s\n",
-               nickname, first_name, last_name, email, jid);
-
-       empathy_account_settings_set_string (settings, "nickname", nickname ? nickname : "");
-       empathy_account_settings_set_string (settings, "first-name", first_name ? first_name : "");
-       empathy_account_settings_set_string (settings, "last-name", last_name ? last_name : "");
-       empathy_account_settings_set_string (settings, "email", email ? email : "");
-       empathy_account_settings_set_string (settings, "jid", jid ? jid : "");
-
-       empathy_account_settings_apply_async (settings,
-               salut_account_created, NULL);
-
-       g_free (nickname);
-       g_free (first_name);
-       g_free (last_name);
-       g_free (email);
-       g_free (jid);
-       g_object_unref (settings);
-       g_object_unref (contact);
-       g_object_unref (book);
+  EmpathyAccountSettings  *settings;
+  TpConnectionManager *manager;
+  const TpConnectionManagerProtocol *protocol;
+  EBook      *book;
+  EContact   *contact;
+  gchar      *nickname = NULL;
+  gchar      *first_name = NULL;
+  gchar      *last_name = NULL;
+  gchar      *email = NULL;
+  gchar      *jid = NULL;
+  GError     *error = NULL;
+
+
+  if (!should_create_salut_account ())
+    return;
+
+  manager = empathy_connection_managers_get_cm (managers, "salut");
+  if (manager == NULL)
+    {
+      DEBUG ("Salut not installed, not making a salut account");
+      return;
+    }
+
+  protocol = tp_connection_manager_get_protocol (manager, "local-xmpp");
+  if (protocol == NULL)
+    {
+      DEBUG ("Salut doesn't support local-xmpp!!");
+      return;
+    }
+
+  DEBUG ("Trying to add a salut account...");
+
+  /* Get self EContact from EDS */
+  if (!e_book_get_self (&contact, &book, &error))
+    {
+      DEBUG ("Failed to get self econtact: %s",
+          error ? error->message : "No error given");
+      g_clear_error (&error);
+      return;
+    }
+
+  settings = empathy_account_settings_new ("salut", "local-xmpp",
+      _("People nearby"));
+
+  nickname = e_contact_get (contact, E_CONTACT_NICKNAME);
+  first_name = e_contact_get (contact, E_CONTACT_GIVEN_NAME);
+  last_name = e_contact_get (contact, E_CONTACT_FAMILY_NAME);
+  email = e_contact_get (contact, E_CONTACT_EMAIL_1);
+  jid = e_contact_get (contact, E_CONTACT_IM_JABBER_HOME_1);
+
+  if (!tp_strdiff (nickname, "nickname"))
+    {
+      g_free (nickname);
+      nickname = NULL;
+    }
+
+  DEBUG ("Salut account created:\nnickname=%s\nfirst-name=%s\n"
+     "last-name=%s\nemail=%s\njid=%s\n",
+     nickname, first_name, last_name, email, jid);
+
+  empathy_account_settings_set_string (settings,
+      "nickname", nickname ? nickname : "");
+  empathy_account_settings_set_string (settings,
+      "first-name", first_name ? first_name : "");
+  empathy_account_settings_set_string (settings,
+      "last-name", last_name ? last_name : "");
+  empathy_account_settings_set_string (settings, "email", email ? email : "");
+  empathy_account_settings_set_string (settings, "jid", jid ? jid : "");
+
+  empathy_account_settings_apply_async (settings,
+      salut_account_created, NULL);
+
+  g_free (nickname);
+  g_free (first_name);
+  g_free (last_name);
+  g_free (email);
+  g_free (jid);
+  g_object_unref (settings);
+  g_object_unref (contact);
+  g_object_unref (book);
 }
 
 static void
 connection_managers_ready_cb (EmpathyConnectionManagers *managers,
-       GParamSpec *spec, gpointer user_data)
+    GParamSpec *spec,
+    gpointer user_data)
 {
-       if (empathy_connection_managers_is_ready (managers))
-               {
-                       create_salut_account_if_needed (managers);
-                       g_object_unref (managers);
-                       managers = NULL;
-               }
+  if (empathy_connection_managers_is_ready (managers))
+    {
+      create_salut_account_if_needed (managers);
+      g_object_unref (managers);
+      managers = NULL;
+    }
 }
 
 static void
 create_salut_account (void)
 {
-       EmpathyConnectionManagers *managers;
-
-       if (!should_create_salut_account ())
-               return;
-
-       managers = empathy_connection_managers_dup_singleton ();
-
-       if (empathy_connection_managers_is_ready (managers))
-               {
-                       create_salut_account_if_needed (managers);
-                       g_object_unref (managers);
-               }
-       else
-               {
-                       g_signal_connect (managers, "notify::ready",
-                               G_CALLBACK (connection_managers_ready_cb), NULL);
-               }
+  EmpathyConnectionManagers *managers;
+
+  if (!should_create_salut_account ())
+    return;
+
+  managers = empathy_connection_managers_dup_singleton ();
+
+  if (empathy_connection_managers_is_ready (managers))
+    {
+      create_salut_account_if_needed (managers);
+      g_object_unref (managers);
+    }
+  else
+    {
+      g_signal_connect (managers, "notify::ready",
+                        G_CALLBACK (connection_managers_ready_cb), NULL);
+    }
 }
 
 static void
 migrate_config_to_xdg_dir (void)
 {
-       gchar *xdg_dir, *old_dir, *xdg_filename, *old_filename;
-       int i;
-       GFile *xdg_file, *old_file;
-       static const gchar* filenames[] = {
-               "geometry.ini",
-               "irc-networks.xml",
-               "chatrooms.xml",
-               "contact-groups.xml",
-               "status-presets.xml",
-               "accels.txt",
-               NULL
-       };
-
-       xdg_dir = g_build_filename (g_get_user_config_dir (), PACKAGE_NAME, NULL);
-       if (g_file_test (xdg_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
-               /* xdg config dir already exists */
-               g_free (xdg_dir);
-               return;
-       }
-
-       old_dir = g_build_filename (g_get_home_dir (), ".gnome2", PACKAGE_NAME, NULL);
-       if (!g_file_test (old_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
-               /* old config dir didn't exist */
-               g_free (xdg_dir);
-               g_free (old_dir);
-               return;
-       }
-
-       if (g_mkdir_with_parents (xdg_dir, (S_IRUSR | S_IWUSR | S_IXUSR)) == -1) {
-               DEBUG ("Failed to create configuration directory; aborting migration");
-               g_free (xdg_dir);
-               g_free (old_dir);
-               return;
-       }
-
-       for (i = 0; filenames[i]; i++) {
-               old_filename = g_build_filename (old_dir, filenames[i], NULL);
-               if (!g_file_test (old_filename, G_FILE_TEST_EXISTS)) {
-                       g_free (old_filename);
-                       continue;
-               }
-               xdg_filename = g_build_filename (xdg_dir, filenames[i], NULL);
-               old_file = g_file_new_for_path (old_filename);
-               xdg_file = g_file_new_for_path (xdg_filename);
-               if (!g_file_move (old_file, xdg_file, G_FILE_COPY_NONE,
-                                 NULL, NULL, NULL, NULL)) {
-                       DEBUG ("Failed to migrate %s", filenames[i]);
-               }
-               g_free (old_filename);
-               g_free (xdg_filename);
-               g_object_unref (old_file);
-               g_object_unref (xdg_file);
-       }
-
-       g_free (xdg_dir);
-       g_free (old_dir);
+  gchar *xdg_dir, *old_dir, *xdg_filename, *old_filename;
+  int i;
+  GFile *xdg_file, *old_file;
+  static const gchar* filenames[] = {
+    "geometry.ini",
+    "irc-networks.xml",
+    "chatrooms.xml",
+    "contact-groups.xml",
+    "status-presets.xml",
+    "accels.txt",
+    NULL
+  };
+
+  xdg_dir = g_build_filename (g_get_user_config_dir (), PACKAGE_NAME, NULL);
+  if (g_file_test (xdg_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
+    {
+      /* xdg config dir already exists */
+      g_free (xdg_dir);
+      return;
+    }
+
+  old_dir = g_build_filename (g_get_home_dir (), ".gnome2", PACKAGE_NAME, NULL);
+  if (!g_file_test (old_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
+    {
+      /* old config dir didn't exist */
+      g_free (xdg_dir);
+      g_free (old_dir);
+      return;
+    }
+
+  if (g_mkdir_with_parents (xdg_dir, (S_IRUSR | S_IWUSR | S_IXUSR)) == -1)
+    {
+      DEBUG ("Failed to create configuration directory; aborting migration");
+      g_free (xdg_dir);
+      g_free (old_dir);
+      return;
+    }
+
+  for (i = 0; filenames[i]; i++)
+    {
+      old_filename = g_build_filename (old_dir, filenames[i], NULL);
+      if (!g_file_test (old_filename, G_FILE_TEST_EXISTS))
+        {
+          g_free (old_filename);
+          continue;
+        }
+      xdg_filename = g_build_filename (xdg_dir, filenames[i], NULL);
+      old_file = g_file_new_for_path (old_filename);
+      xdg_file = g_file_new_for_path (xdg_filename);
+
+      if (!g_file_move (old_file, xdg_file, G_FILE_COPY_NONE,
+          NULL, NULL, NULL, NULL))
+        DEBUG ("Failed to migrate %s", filenames[i]);
+
+      g_free (old_filename);
+      g_free (xdg_filename);
+      g_object_unref (old_file);
+      g_object_unref (xdg_file);
+    }
+
+  g_free (xdg_dir);
+  g_free (old_dir);
 }
 
 static UniqueResponse
 unique_app_message_cb (UniqueApp *unique_app,
-                       gint command,
-                       UniqueMessageData *data,
-                       guint timestamp,
-                       gpointer user_data)
+    gint command,
+    UniqueMessageData *data,
+    guint timestamp,
+    gpointer user_data)
 {
-       GtkWidget *window = user_data;
-
-       DEBUG ("Other instance launched, presenting the main window. "
-              "Command=%d, timestamp %u", command, timestamp);
-
-       if (command == COMMAND_ACCOUNTS_DIALOG) {
-               empathy_accounts_dialog_show (GTK_WINDOW (window), NULL);
-       } else {
-               gtk_window_set_screen (GTK_WINDOW (window),
-                                      unique_message_data_get_screen (data));
-               gtk_window_set_startup_id (GTK_WINDOW (window),
-                                          unique_message_data_get_startup_id (data));
-               gtk_window_present_with_time (GTK_WINDOW (window), timestamp);
-       }
-
-       return UNIQUE_RESPONSE_OK;
+  GtkWidget *window = user_data;
+
+  DEBUG ("Other instance launched, presenting the main window. "
+      "Command=%d, timestamp %u", command, timestamp);
+
+  if (command == COMMAND_ACCOUNTS_DIALOG)
+    {
+      empathy_accounts_dialog_show (GTK_WINDOW (window), NULL);
+    }
+  else
+    {
+      gtk_window_set_screen (GTK_WINDOW (window),
+          unique_message_data_get_screen (data));
+      gtk_window_set_startup_id (GTK_WINDOW (window),
+          unique_message_data_get_startup_id (data));
+      gtk_window_present_with_time (GTK_WINDOW (window), timestamp);
+    }
+
+  return UNIQUE_RESPONSE_OK;
 }
 
 static gboolean
 show_version_cb (const char *option_name,
-                 const char *value,
-                 gpointer data,
-                 GError **error)
+    const char *value,
+    gpointer data,
+    GError **error)
 {
-       g_print ("%s\n", PACKAGE_STRING);
+  g_print ("%s\n", PACKAGE_STRING);
 
-       exit (EXIT_SUCCESS);
+  exit (EXIT_SUCCESS);
 
-       return FALSE;
+  return FALSE;
 }
 
 static void
 new_incoming_transfer_cb (EmpathyFTFactory *factory,
-                         EmpathyFTHandler *handler,
-                          GError *error,
-                         gpointer user_data)
+    EmpathyFTHandler *handler,
+    GError *error,
+    gpointer user_data)
 {
-       if (error) {
-               empathy_ft_manager_display_error (handler, error);
-       } else {
-               empathy_receive_file_with_file_chooser (handler);
-       }
+  if (error)
+    empathy_ft_manager_display_error (handler, error);
+  else
+    empathy_receive_file_with_file_chooser (handler);
 }
 
 static void
 new_ft_handler_cb (EmpathyFTFactory *factory,
-                  EmpathyFTHandler *handler,
-                   GError *error,
-                  gpointer user_data)
+    EmpathyFTHandler *handler,
+    GError *error,
+    gpointer user_data)
 {
-       if (error) {
-               empathy_ft_manager_display_error (handler, error);
-       } else {
-               empathy_ft_manager_add_handler (handler);
-       }
+  if (error)
+    empathy_ft_manager_display_error (handler, error);
+  else
+    empathy_ft_manager_add_handler (handler);
 
-       g_object_unref (handler);
+  g_object_unref (handler);
 }
 
 static void
-new_call_handler_cb (EmpathyCallFactory *factory, EmpathyCallHandler *handler,
-       gboolean outgoing, gpointer user_data)
+new_call_handler_cb (EmpathyCallFactory *factory,
+    EmpathyCallHandler *handler,
+    gboolean outgoing,
+    gpointer user_data)
 {
-       EmpathyCallWindow *window;
+  EmpathyCallWindow *window;
 
-       window = empathy_call_window_new (handler);
-       gtk_widget_show (GTK_WIDGET (window));
+  window = empathy_call_window_new (handler);
+  gtk_widget_show (GTK_WIDGET (window));
 }
 
 #ifdef ENABLE_DEBUG
@@ -487,237 +508,236 @@ default_log_handler (const gchar *log_domain,
     const gchar *message,
     gpointer user_data)
 {
-       g_log_default_handler (log_domain, log_level, message, NULL);
-
-       /* G_LOG_DOMAIN = "empathy". No need to send empathy messages to the
-        * debugger as they already have in empathy_debug. */
-       if (log_level != G_LOG_LEVEL_DEBUG
-           || tp_strdiff (log_domain, G_LOG_DOMAIN)) {
-               EmpathyDebugger *dbg;
-               GTimeVal now;
-
-               dbg = empathy_debugger_get_singleton ();
-               g_get_current_time (&now);
-
-               empathy_debugger_add_message (dbg, &now, log_domain,
-                                             log_level, message);
-       }
+  g_log_default_handler (log_domain, log_level, message, NULL);
+
+  /* G_LOG_DOMAIN = "empathy". No need to send empathy messages to the
+   * debugger as they already have in empathy_debug. */
+  if (log_level != G_LOG_LEVEL_DEBUG
+      || tp_strdiff (log_domain, G_LOG_DOMAIN))
+    {
+        EmpathyDebugger *dbg;
+        GTimeVal now;
+
+        dbg = empathy_debugger_get_singleton ();
+        g_get_current_time (&now);
+
+        empathy_debugger_add_message (dbg, &now, log_domain,
+                                      log_level, message);
+    }
 }
 #endif /* ENABLE_DEBUG */
 
 static void
 account_manager_ready_cb (EmpathyAccountManager *manager,
-       GParamSpec *spec,
-       gpointer user_data)
+    GParamSpec *spec,
+    gpointer user_data)
 {
-       if (!empathy_account_manager_is_ready (manager))
-               return;
-
-       if (empathy_account_manager_get_count (manager) == 0)
-               {
-                       empathy_accounts_dialog_show (GTK_WINDOW (empathy_main_window_get ()),
-                               NULL);
-               }
-       create_salut_account ();
+  if (!empathy_account_manager_is_ready (manager))
+    return;
+
+  if (empathy_account_manager_get_count (manager) == 0)
+    empathy_accounts_dialog_show (GTK_WINDOW (empathy_main_window_get ()),
+        NULL);
+
+  create_salut_account ();
 }
 
 int
 main (int argc, char *argv[])
 {
 #if HAVE_GEOCLUE
-       EmpathyLocationManager *location_manager = NULL;
+  EmpathyLocationManager *location_manager = NULL;
 #endif
-       EmpathyStatusIcon *icon;
-       EmpathyDispatcher *dispatcher;
-       EmpathyAccountManager *account_manager;
-       EmpathyLogManager *log_manager;
-       EmpathyChatroomManager *chatroom_manager;
-       EmpathyCallFactory *call_factory;
-       EmpathyFTFactory  *ft_factory;
-       GtkWidget         *window;
-       EmpathyIdle       *idle;
-       EmpathyConnectivity *connectivity;
-       gboolean           autoconnect = TRUE;
-       gboolean           no_connect = FALSE;
-       gboolean           hide_contact_list = FALSE;
-       gboolean           accounts_dialog = FALSE;
-       GError            *error = NULL;
-       TpDBusDaemon      *dbus_daemon;
-       UniqueApp         *unique_app;
-       GOptionEntry       options[] = {
-               { "no-connect", 'n',
-                 0, G_OPTION_ARG_NONE, &no_connect,
-                 N_("Don't connect on startup"),
-                 NULL },
-               { "hide-contact-list", 'h',
-                 0, G_OPTION_ARG_NONE, &hide_contact_list,
-                 N_("Don't show the contact list on startup"),
-                 NULL },
-               { "accounts", 'a',
-                 0, G_OPTION_ARG_NONE, &accounts_dialog,
-                 N_("Show the accounts dialog"),
-                 NULL },
-               { "version", 'v',
-                 G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb, NULL, NULL },
-               { NULL }
-       };
-
-       /* Init */
-       g_thread_init (NULL);
-       empathy_init ();
-
-       if (!gtk_init_with_args (&argc, &argv,
-                                N_("- Empathy IM Client"),
-                                options, GETTEXT_PACKAGE, &error)) {
-               g_warning ("Error in empathy init: %s", error->message);
-               return EXIT_FAILURE;
-       }
-
-       empathy_gtk_init ();
-       g_set_application_name (_(PACKAGE_NAME));
-       g_setenv ("PULSE_PROP_media.role", "phone", TRUE);
-
-       gst_init (&argc, &argv);
+  EmpathyStatusIcon *icon;
+  EmpathyDispatcher *dispatcher;
+  EmpathyAccountManager *account_manager;
+  EmpathyLogManager *log_manager;
+  EmpathyChatroomManager *chatroom_manager;
+  EmpathyCallFactory *call_factory;
+  EmpathyFTFactory  *ft_factory;
+  GtkWidget *window;
+  EmpathyIdle *idle;
+  EmpathyConnectivity *connectivity;
+  gboolean autoconnect = TRUE;
+  gboolean no_connect = FALSE;
+  gboolean hide_contact_list = FALSE;
+  gboolean accounts_dialog = FALSE;
+  GError *error = NULL;
+  TpDBusDaemon *dbus_daemon;
+  UniqueApp *unique_app;
+
+  GOptionEntry options[] = {
+      { "no-connect", 'n',
+        0, G_OPTION_ARG_NONE, &no_connect,
+        N_("Don't connect on startup"),
+        NULL },
+      { "hide-contact-list", 'h',
+        0, G_OPTION_ARG_NONE, &hide_contact_list,
+        N_("Don't show the contact list on startup"),
+        NULL },
+      { "accounts", 'a',
+        0, G_OPTION_ARG_NONE, &accounts_dialog,
+        N_("Show the accounts dialog"),
+        NULL },
+      { "version", 'v',
+        G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb,
+        NULL, NULL },
+      { NULL }
+  };
+
+  /* Init */
+  g_thread_init (NULL);
+  empathy_init ();
+
+  if (!gtk_init_with_args (&argc, &argv, N_("- Empathy IM Client"),
+      options, GETTEXT_PACKAGE, &error))
+    {
+      g_warning ("Error in empathy init: %s", error->message);
+      return EXIT_FAILURE;
+    }
+
+  empathy_gtk_init ();
+  g_set_application_name (_(PACKAGE_NAME));
+  g_setenv ("PULSE_PROP_media.role", "phone", TRUE);
+
+  gst_init (&argc, &argv);
 
 #if HAVE_LIBCHAMPLAIN
-       gtk_clutter_init (&argc, &argv);
+  gtk_clutter_init (&argc, &argv);
 #endif
 
-       gtk_window_set_default_icon_name ("empathy");
-       textdomain (GETTEXT_PACKAGE);
+  gtk_window_set_default_icon_name ("empathy");
+  textdomain (GETTEXT_PACKAGE);
 
 #ifdef ENABLE_DEBUG
-       /* Set up debugger */
-       g_log_set_default_handler (default_log_handler, NULL);
+  /* Set up debugger */
+  g_log_set_default_handler (default_log_handler, NULL);
 #endif
 
-       unique_app = unique_app_new_with_commands ("org.gnome.Empathy",
-                                                  NULL,
-                                                  "accounts_dialog",
-                                                  COMMAND_ACCOUNTS_DIALOG,
-                                                  NULL);
-
-       if (unique_app_is_running (unique_app)) {
-               unique_app_send_message (unique_app,
-                                        accounts_dialog ?
-                                        COMMAND_ACCOUNTS_DIALOG :
-                                                UNIQUE_ACTIVATE,
-                                        NULL);
-               g_object_unref (unique_app);
-               return EXIT_SUCCESS;
-       }
-
-       /* Take well-known name */
-       dbus_daemon = tp_dbus_daemon_dup (&error);
-       if (error == NULL) {
-               if (!tp_dbus_daemon_request_name (dbus_daemon,
-                                                 "org.gnome.Empathy",
-                                                 TRUE, &error)) {
-                       DEBUG ("Failed to request well-known name: %s",
-                              error ? error->message : "no message");
-                       g_clear_error (&error);
-               }
-               g_object_unref (dbus_daemon);
-       } else {
-               DEBUG ("Failed to dup dbus daemon: %s",
-                      error ? error->message : "no message");
-               g_clear_error (&error);
-       }
-
-       if (accounts_dialog) {
-               GtkWidget *dialog;
-
-               dialog = empathy_accounts_dialog_show (NULL, NULL);
-               g_signal_connect (dialog, "destroy",
-                                 G_CALLBACK (gtk_main_quit),
-                                 NULL);
-
-               gtk_main ();
-               return 0;
-       }
-
-       /* Setting up Idle */
-       idle = empathy_idle_dup_singleton ();
-       empathy_idle_set_auto_away (idle, TRUE);
-
-       /* Setting up Connectivity */
-       connectivity = empathy_connectivity_dup_singleton ();
-       use_conn_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
-                           connectivity);
-       empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
-                                use_conn_notify_cb, connectivity);
-
-       /* Autoconnect */
-       empathy_conf_get_bool (empathy_conf_get (),
-                              EMPATHY_PREFS_AUTOCONNECT,
-                              &autoconnect);
-       if (autoconnect && ! no_connect &&
-               tp_connection_presence_type_cmp_availability (empathy_idle_get_state
-                       (idle), TP_CONNECTION_PRESENCE_TYPE_OFFLINE) <= 0) {
-               empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE);
-       }
-
-       /* account management */
-       account_manager = empathy_account_manager_dup_singleton ();
-       g_signal_connect (account_manager, "notify::ready",
-               G_CALLBACK (account_manager_ready_cb), NULL);
-
-       migrate_config_to_xdg_dir ();
-
-       /* Setting up UI */
-       window = empathy_main_window_show ();
-       icon = empathy_status_icon_new (GTK_WINDOW (window), hide_contact_list);
-
-       g_signal_connect (unique_app, "message-received",
-                         G_CALLBACK (unique_app_message_cb),
-                         window);
-
-       /* Handle channels */
-       dispatcher = empathy_dispatcher_dup_singleton ();
-       g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL);
-
-       /* Logging */
-       log_manager = empathy_log_manager_dup_singleton ();
-       empathy_log_manager_observe (log_manager, dispatcher);
-
-       chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
-       empathy_chatroom_manager_observe (chatroom_manager, dispatcher);
-
-       notify_init (_(PACKAGE_NAME));
-       /* Create the call factory */
-       call_factory = empathy_call_factory_initialise ();
-       g_signal_connect (G_OBJECT (call_factory), "new-call-handler",
-               G_CALLBACK (new_call_handler_cb), NULL);
-       /* Create the FT factory */
-       ft_factory = empathy_ft_factory_dup_singleton ();
-       g_signal_connect (ft_factory, "new-ft-handler",
-               G_CALLBACK (new_ft_handler_cb), NULL);
-       g_signal_connect (ft_factory, "new-incoming-transfer",
-               G_CALLBACK (new_incoming_transfer_cb), NULL);
-
-       /* Location mananger */
+  unique_app = unique_app_new_with_commands ("org.gnome.Empathy",
+      NULL, "accounts_dialog", COMMAND_ACCOUNTS_DIALOG, NULL);
+
+  if (unique_app_is_running (unique_app))
+    {
+      unique_app_send_message (unique_app, accounts_dialog ?
+          COMMAND_ACCOUNTS_DIALOG : UNIQUE_ACTIVATE, NULL);
+
+      g_object_unref (unique_app);
+      return EXIT_SUCCESS;
+    }
+
+  /* Take well-known name */
+  dbus_daemon = tp_dbus_daemon_dup (&error);
+  if (error == NULL)
+    {
+      if (!tp_dbus_daemon_request_name (dbus_daemon,
+          "org.gnome.Empathy", TRUE, &error))
+        {
+          DEBUG ("Failed to request well-known name: %s",
+                 error ? error->message : "no message");
+          g_clear_error (&error);
+        }
+      g_object_unref (dbus_daemon);
+    }
+  else
+    {
+      DEBUG ("Failed to dup dbus daemon: %s",
+             error ? error->message : "no message");
+      g_clear_error (&error);
+    }
+
+  if (accounts_dialog)
+    {
+      GtkWidget *dialog;
+
+      dialog = empathy_accounts_dialog_show (NULL, NULL);
+      g_signal_connect (dialog, "destroy",
+                        G_CALLBACK (gtk_main_quit), NULL);
+
+      gtk_main ();
+      return 0;
+    }
+
+  /* Setting up Idle */
+  idle = empathy_idle_dup_singleton ();
+  empathy_idle_set_auto_away (idle, TRUE);
+
+  /* Setting up Connectivity */
+  connectivity = empathy_connectivity_dup_singleton ();
+  use_conn_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
+      connectivity);
+  empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
+      use_conn_notify_cb, connectivity);
+
+  /* Autoconnect */
+  empathy_conf_get_bool (empathy_conf_get (),
+      EMPATHY_PREFS_AUTOCONNECT, &autoconnect);
+  if (autoconnect && !no_connect &&
+      tp_connection_presence_type_cmp_availability
+          (empathy_idle_get_state (idle), TP_CONNECTION_PRESENCE_TYPE_OFFLINE)
+            <= 0)
+      empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_AVAILABLE);
+
+  /* account management */
+  account_manager = empathy_account_manager_dup_singleton ();
+  g_signal_connect (account_manager, "notify::ready",
+      G_CALLBACK (account_manager_ready_cb), NULL);
+
+  migrate_config_to_xdg_dir ();
+
+  /* Setting up UI */
+  window = empathy_main_window_show ();
+  icon = empathy_status_icon_new (GTK_WINDOW (window), hide_contact_list);
+
+  g_signal_connect (unique_app, "message-received",
+      G_CALLBACK (unique_app_message_cb), window);
+
+  /* Handle channels */
+  dispatcher = empathy_dispatcher_dup_singleton ();
+  g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL);
+
+  /* Logging */
+  log_manager = empathy_log_manager_dup_singleton ();
+  empathy_log_manager_observe (log_manager, dispatcher);
+
+  chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
+  empathy_chatroom_manager_observe (chatroom_manager, dispatcher);
+
+  notify_init (_(PACKAGE_NAME));
+  /* Create the call factory */
+  call_factory = empathy_call_factory_initialise ();
+  g_signal_connect (G_OBJECT (call_factory), "new-call-handler",
+      G_CALLBACK (new_call_handler_cb), NULL);
+  /* Create the FT factory */
+  ft_factory = empathy_ft_factory_dup_singleton ();
+  g_signal_connect (ft_factory, "new-ft-handler",
+      G_CALLBACK (new_ft_handler_cb), NULL);
+  g_signal_connect (ft_factory, "new-incoming-transfer",
+      G_CALLBACK (new_incoming_transfer_cb), NULL);
+
+  /* Location mananger */
 #if HAVE_GEOCLUE
-       location_manager = empathy_location_manager_dup_singleton ();
+  location_manager = empathy_location_manager_dup_singleton ();
 #endif
 
-       gtk_main ();
+  gtk_main ();
 
-       empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
+  empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
 
-       g_object_unref (idle);
-       g_object_unref (connectivity);
-       g_object_unref (icon);
-       g_object_unref (account_manager);
-       g_object_unref (log_manager);
-       g_object_unref (dispatcher);
-       g_object_unref (chatroom_manager);
+  g_object_unref (idle);
+  g_object_unref (connectivity);
+  g_object_unref (icon);
+  g_object_unref (account_manager);
+  g_object_unref (log_manager);
+  g_object_unref (dispatcher);
+  g_object_unref (chatroom_manager);
 #if HAVE_GEOCLUE
-       g_object_unref (location_manager);
+  g_object_unref (location_manager);
 #endif
-       g_object_unref (ft_factory);
-       g_object_unref (unique_app);
+  g_object_unref (ft_factory);
+  g_object_unref (unique_app);
 
-       notify_uninit ();
+  notify_uninit ();
 
-       return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 }