src/empathy-import-dialog.c

   1 /*
   2  * Copyright (C) 2008 Collabora Ltd.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  *
  19  * Authors: Jonny Lamb <jonny.lamb@collabora.co.uk>
  20  * */
  21
  22 #include <config.h>
  23
  24 #include <string.h>
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>
  28 #include <glade/glade.h>
  29 #include <glib/gi18n.h>
  30
  31 #include <libmissioncontrol/mc-account.h>
  32 #include <telepathy-glib/util.h>
  33
  34 #include "empathy-import-dialog.h"
  35 #include "empathy-import-pidgin.h"
  36
  37 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  38 #include <libempathy/empathy-debug.h>
  39 #include <libempathy/empathy-utils.h>
  40
  41 #include <libempathy-gtk/empathy-ui-utils.h>
  42
  43 typedef struct
  44 {
  45   GtkWidget *window;
  46   GtkWidget *treeview;
  47   GtkWidget *button_ok;
  48   GtkWidget *button_cancel;
  49   GList *accounts;
  50 } EmpathyImportDialog;
  51
  52 enum
  53 {
  54   COL_IMPORT = 0,
  55   COL_PROTOCOL,
  56   COL_NAME,
  57   COL_SOURCE,
  58   COL_ACCOUNT_DATA,
  59   COL_COUNT
  60 };
  61
  62 EmpathyImportAccountData *
  63 empathy_import_account_data_new (const gchar *source)
  64 {
  65   EmpathyImportAccountData *data;
  66
  67   g_return_val_if_fail (!EMP_STR_EMPTY (source), NULL);
  68
  69   data = g_slice_new0 (EmpathyImportAccountData);
  70   data->settings = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
  71     (GDestroyNotify) tp_g_value_slice_free);
  72   data->source = g_strdup (source);
  73
  74   return data;
  75 }
  76
  77 void
  78 empathy_import_account_data_free (EmpathyImportAccountData *data)
  79 {
  80   if (data == NULL)
  81     return;
  82   if (data->profile != NULL)
  83     g_object_unref (data->profile);
  84   if (data->settings != NULL)
  85     g_hash_table_destroy (data->settings);
  86   if (data->source != NULL)
  87     g_free (data->source);
  88
  89   g_slice_free (EmpathyImportAccountData, data);
  90 }
  91
  92 static void
  93 import_dialog_add_account (EmpathyImportAccountData *data)
  94 {
  95   McAccount *account;
  96   GHashTableIter iter;
  97   gpointer key, value;
  98   gchar *display_name;
  99   GValue *username;
 100
 101   account = mc_account_create (data->profile);
 102
 103   g_hash_table_iter_init (&iter, data->settings);
 104   while (g_hash_table_iter_next (&iter, &key, &value))
 105     {
 106       const gchar *param = key;
 107       GValue *gvalue = value;
 108
 109       switch (G_VALUE_TYPE (gvalue))
 110         {
 111           case G_TYPE_STRING:
 112             DEBUG ("Set param '%s' to '%s' (string)",
 113                 param, g_value_get_string (gvalue));
 114             mc_account_set_param_string (account,
 115                 param, g_value_get_string (gvalue));
 116             break;
 117
 118           case G_TYPE_BOOLEAN:
 119             DEBUG ("Set param '%s' to %s (boolean)",
 120                 param, g_value_get_boolean (gvalue) ? "TRUE" : "FALSE");
 121             mc_account_set_param_boolean (account,
 122                 param, g_value_get_boolean (gvalue));
 123             break;
 124
 125           case G_TYPE_INT:
 126             DEBUG ("Set param '%s' to '%i' (integer)",
 127                 param, g_value_get_int (gvalue));
 128             mc_account_set_param_int (account,
 129                 param, g_value_get_int (gvalue));
 130             break;
 131         }
 132     }
 133
 134   /* Set the display name of the account */
 135   username = g_hash_table_lookup (data->settings, "account");
 136   display_name = g_strdup_printf ("%s (%s)",
 137       mc_profile_get_display_name (data->profile),
 138       g_value_get_string (username));
 139   mc_account_set_display_name (account, display_name);
 140
 141   g_free (display_name);
 142   g_object_unref (account);
 143 }
 144
 145 static gboolean
 146 import_dialog_account_id_in_list (GList *accounts,
 147                                   const gchar *account_id)
 148 {
 149   GList *l;
 150
 151   for (l = accounts; l; l = l->next)
 152     {
 153       McAccount *account = l->data;
 154       gchar *value;
 155       gboolean result;
 156
 157       if (mc_account_get_param_string (account, "account", &value)
 158           == MC_ACCOUNT_SETTING_ABSENT)
 159         continue;
 160
 161       result = tp_strdiff (value, account_id);
 162
 163       g_free (value);
 164
 165       if (!result)
 166         return TRUE;
 167     }
 168
 169   return FALSE;
 170 }
 171
 172 static void
 173 import_dialog_add_accounts_to_model (EmpathyImportDialog *dialog)
 174 {
 175   GtkTreeModel *model;
 176   GtkTreeIter iter;
 177   GList *l;
 178
 179   model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview));
 180
 181   for (l = dialog->accounts; l; l = l->next)
 182     {
 183       GValue *value;
 184       EmpathyImportAccountData *data = l->data;
 185       gboolean import;
 186       GList *accounts;
 187
 188       value = g_hash_table_lookup (data->settings, "account");
 189
 190       accounts = mc_accounts_list_by_profile (data->profile);
 191
 192       /* Only set the "Import" cell to be active if there isn't already an
 193        * account set up with the same account id. */
 194       import = !import_dialog_account_id_in_list (accounts,
 195           g_value_get_string (value));
 196
 197       mc_accounts_list_free (accounts);
 198
 199       gtk_list_store_append (GTK_LIST_STORE (model), &iter);
 200
 201       gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 202           COL_IMPORT, import,
 203           COL_PROTOCOL, mc_profile_get_display_name (data->profile),
 204           COL_NAME, g_value_get_string (value),
 205           COL_SOURCE, data->source,
 206           COL_ACCOUNT_DATA, data,
 207           -1);
 208     }
 209 }
 210
 211 static void
 212 import_dialog_cell_toggled_cb (GtkCellRendererToggle *cell_renderer,
 213                                const gchar *path_str,
 214                                EmpathyImportDialog *dialog)
 215 {
 216   GtkTreeModel *model;
 217   GtkTreeIter iter;
 218   GtkTreePath *path;
 219
 220   path = gtk_tree_path_new_from_string (path_str);
 221   model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview));
 222
 223   gtk_tree_model_get_iter (model, &iter, path);
 224
 225   gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 226       COL_IMPORT, !gtk_cell_renderer_toggle_get_active (cell_renderer),
 227       -1);
 228
 229   gtk_tree_path_free (path);
 230 }
 231
 232 static void
 233 import_dialog_set_up_account_list (EmpathyImportDialog *dialog)
 234 {
 235   GtkListStore *store;
 236   GtkTreeView *view;
 237   GtkTreeViewColumn *column;
 238   GtkCellRenderer *cell;
 239
 240   store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING,
 241       G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
 242
 243   gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview),
 244       GTK_TREE_MODEL (store));
 245
 246   g_object_unref (store);
 247
 248   view = GTK_TREE_VIEW (dialog->treeview);
 249   gtk_tree_view_set_headers_visible (view, TRUE);
 250
 251   /* Import column */
 252   cell = gtk_cell_renderer_toggle_new ();
 253   gtk_tree_view_insert_column_with_attributes (view, -1,
 254       _("Import"), cell,
 255       "active", COL_IMPORT,
 256       NULL);
 257
 258   g_signal_connect (cell, "toggled",
 259       G_CALLBACK (import_dialog_cell_toggled_cb), dialog);
 260
 261   /* Protocol column */
 262   column = gtk_tree_view_column_new ();
 263   gtk_tree_view_column_set_title (column, _("Protocol"));
 264   gtk_tree_view_column_set_expand (column, TRUE);
 265   gtk_tree_view_append_column (view, column);
 266
 267   cell = gtk_cell_renderer_text_new ();
 268   g_object_set (cell,
 269       "editable", FALSE,
 270       NULL);
 271   gtk_tree_view_column_pack_start (column, cell, TRUE);
 272   gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL);
 273
 274   /* Account column */
 275   column = gtk_tree_view_column_new ();
 276   gtk_tree_view_column_set_title (column, _("Account"));
 277   gtk_tree_view_column_set_expand (column, TRUE);
 278   gtk_tree_view_append_column (view, column);
 279
 280   cell = gtk_cell_renderer_text_new ();
 281   g_object_set (cell,
 282       "editable", FALSE,
 283       NULL);
 284   gtk_tree_view_column_pack_start (column, cell, TRUE);
 285   gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME);
 286
 287   /* Source column */
 288   column = gtk_tree_view_column_new ();
 289   gtk_tree_view_column_set_title (column, _("Source"));
 290   gtk_tree_view_column_set_expand (column, TRUE);
 291   gtk_tree_view_append_column (view, column);
 292
 293   cell = gtk_cell_renderer_text_new ();
 294   g_object_set (cell,
 295       "editable", FALSE,
 296       NULL);
 297   gtk_tree_view_column_pack_start (column, cell, TRUE);
 298   gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE);
 299
 300   import_dialog_add_accounts_to_model (dialog);
 301 }
 302
 303 static gboolean
 304 import_dialog_tree_model_foreach (GtkTreeModel *model,
 305                                   GtkTreePath *path,
 306                                   GtkTreeIter *iter,
 307                                   gpointer user_data)
 308 {
 309   gboolean to_import;
 310   EmpathyImportAccountData *data;
 311
 312   gtk_tree_model_get (model, iter,
 313       COL_IMPORT, &to_import,
 314       COL_ACCOUNT_DATA, &data,
 315       -1);
 316
 317   if (to_import)
 318     import_dialog_add_account (data);
 319
 320   return FALSE;
 321 }
 322
 323 static void
 324 import_dialog_response_cb (GtkWidget *widget,
 325                            gint response,
 326                            EmpathyImportDialog *dialog)
 327 {
 328   if (response == GTK_RESPONSE_OK)
 329     {
 330       GtkTreeModel *model;
 331
 332       model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview));
 333       gtk_tree_model_foreach (model, import_dialog_tree_model_foreach, dialog);
 334     }
 335
 336   gtk_widget_destroy (dialog->window);
 337 }
 338
 339 static void
 340 import_dialog_destroy_cb (GtkWidget *widget,
 341                           EmpathyImportDialog *dialog)
 342 {
 343   g_list_foreach (dialog->accounts, (GFunc) empathy_import_account_data_free,
 344     NULL);
 345   g_list_free (dialog->accounts);
 346   g_slice_free (EmpathyImportDialog, dialog);
 347 }
 348
 349 void
 350 empathy_import_dialog_show (GtkWindow *parent,
 351                             gboolean warning)
 352 {
 353   static EmpathyImportDialog *dialog = NULL;
 354   GladeXML *glade;
 355   gchar *filename;
 356   GList *accounts = NULL;
 357
 358   /* This window is a singleton. If it already exist, present it */
 359   if (dialog)
 360     {
 361       gtk_window_present (GTK_WINDOW (dialog->window));
 362       return;
 363     }
 364
 365   /* Load all accounts from all supported applications */
 366   accounts = g_list_concat (accounts, empathy_import_pidgin_load ());
 367
 368   /* Check if we have accounts to import before creating the window */
 369   if (!accounts)
 370     {
 371       GtkWidget *message;
 372
 373       if (warning)
 374         {
 375           message = gtk_message_dialog_new (parent,
 376               GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
 377               _("No accounts to import could be found. Empathy currently only "
 378                 "supports importing accounts from Pidgin."));
 379
 380           gtk_dialog_run (GTK_DIALOG (message));
 381           gtk_widget_destroy (message);
 382         }
 383       else
 384         DEBUG ("No accounts to import; closing dialog silently.");
 385
 386       return;
 387     }
 388
 389   /* We have accounts, let's display the window with them */
 390   dialog = g_slice_new0 (EmpathyImportDialog);
 391   dialog->accounts = accounts;
 392
 393   filename = empathy_file_lookup ("empathy-import-dialog.glade", "src");
 394   glade = empathy_glade_get_file (filename,
 395       "import_dialog",
 396       NULL,
 397       "import_dialog", &dialog->window,
 398       "treeview", &dialog->treeview,
 399       NULL);
 400
 401   empathy_glade_connect (glade,
 402       dialog,
 403       "import_dialog", "destroy", import_dialog_destroy_cb,
 404       "import_dialog", "response", import_dialog_response_cb,
 405       NULL);
 406
 407   g_object_add_weak_pointer (G_OBJECT (dialog->window), (gpointer) &dialog);
 408
 409   g_free (filename);
 410   g_object_unref (glade);
 411
 412   if (parent)
 413     gtk_window_set_transient_for (GTK_WINDOW (dialog->window), parent);
 414
 415   import_dialog_set_up_account_list (dialog);
 416
 417   gtk_widget_show (dialog->window);
 418 }
 419