libempathy-gtk/empathy-account-chooser.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2005-2007 Imendio AB
   4  * Copyright (C) 2007-2008 Collabora Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  *
  21  * Authors: Martyn Russell <martyn@imendio.com>
  22  *          Xavier Claessens <xclaesse@gmail.com>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28
  29 #include <glib/gi18n-lib.h>
  30 #include <gtk/gtk.h>
  31
  32 #include <telepathy-glib/account-manager.h>
  33 #include <telepathy-glib/util.h>
  34
  35 #include <libempathy/empathy-utils.h>
  36
  37 #include "empathy-ui-utils.h"
  38 #include "empathy-account-chooser.h"
  39
  40 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  41 #include <libempathy/empathy-debug.h>
  42
  43 /**
  44  * SECTION:empathy-account-chooser
  45  * @title:EmpathyAccountChooser
  46  * @short_description: A widget used to choose from a list of accounts
  47  * @include: libempathy-gtk/empathy-account-chooser.h
  48  *
  49  * #EmpathyAccountChooser is a widget which extends #GtkComboBox to provide
  50  * a chooser of available accounts.
  51  */
  52
  53 /**
  54  * EmpathyAccountChooser:
  55  * @parent: parent object
  56  *
  57  * Widget which extends #GtkComboBox to provide a chooser of available accounts.
  58  */
  59
  60 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountChooser)
  61 typedef struct {
  62         TpAccountManager               *manager;
  63         gboolean                        set_active_item;
  64         gboolean                        account_manually_set;
  65         gboolean                        has_all_option;
  66         EmpathyAccountChooserFilterFunc filter;
  67         gpointer                        filter_data;
  68         gboolean                        ready;
  69 } EmpathyAccountChooserPriv;
  70
  71 typedef struct {
  72         EmpathyAccountChooser *chooser;
  73         TpAccount             *account;
  74         gboolean               set;
  75 } SetAccountData;
  76
  77 typedef struct {
  78         EmpathyAccountChooser *chooser;
  79         TpAccount             *account;
  80         GtkTreeIter           *iter;
  81 } FilterResultCallbackData;
  82
  83 static FilterResultCallbackData *
  84 filter_result_callback_data_new (EmpathyAccountChooser *chooser,
  85                                  TpAccount             *account,
  86                                  GtkTreeIter           *iter)
  87 {
  88         FilterResultCallbackData *data;
  89
  90         data = g_slice_new0 (FilterResultCallbackData);
  91         data->chooser = g_object_ref (chooser);
  92         data->account = g_object_ref (account);
  93         data->iter = gtk_tree_iter_copy (iter);
  94
  95         return data;
  96 }
  97
  98 static void
  99 filter_result_callback_data_free (FilterResultCallbackData *data)
 100 {
 101         g_object_unref (data->chooser);
 102         g_object_unref (data->account);
 103         gtk_tree_iter_free (data->iter);
 104         g_slice_free (FilterResultCallbackData, data);
 105 }
 106
 107 /* Distinguishes between store entries which are actually accounts, and special
 108  * items like the "All" entry and the separator below it, so they can be sorted
 109  * correctly. Higher-numbered entries will sort earlier.
 110  */
 111 typedef enum {
 112         ROW_ACCOUNT = 0,
 113         ROW_SEPARATOR,
 114         ROW_ALL
 115 } RowType;
 116
 117 enum {
 118         COL_ACCOUNT_IMAGE,
 119         COL_ACCOUNT_TEXT,
 120         COL_ACCOUNT_ENABLED, /* Usually tied to connected state */
 121         COL_ACCOUNT_ROW_TYPE,
 122         COL_ACCOUNT_POINTER,
 123         COL_ACCOUNT_COUNT
 124 };
 125
 126 static void     account_chooser_constructed            (GObject                  *object);
 127 static void     account_chooser_finalize               (GObject                  *object);
 128 static void     account_chooser_get_property           (GObject                  *object,
 129                                                         guint                     param_id,
 130                                                         GValue                   *value,
 131                                                         GParamSpec               *pspec);
 132 static void     account_chooser_set_property           (GObject                  *object,
 133                                                         guint                     param_id,
 134                                                         const GValue             *value,
 135                                                         GParamSpec               *pspec);
 136 static void     account_chooser_setup                  (EmpathyAccountChooser    *chooser);
 137 static void     account_chooser_account_validity_changed_cb (TpAccountManager    *manager,
 138                                                         TpAccount                *account,
 139                                                         gboolean                  valid,
 140                                                         EmpathyAccountChooser    *chooser);
 141 static void     account_chooser_account_add_foreach    (TpAccount                *account,
 142                                                         EmpathyAccountChooser    *chooser);
 143 static void     account_chooser_account_removed_cb     (TpAccountManager         *manager,
 144                                                         TpAccount                *account,
 145                                                         EmpathyAccountChooser    *chooser);
 146 static void     account_chooser_account_remove_foreach (TpAccount                *account,
 147                                                         EmpathyAccountChooser    *chooser);
 148 static void     account_chooser_update_iter            (EmpathyAccountChooser    *chooser,
 149                                                         GtkTreeIter              *iter);
 150 static void     account_chooser_status_changed_cb      (TpAccount  *account,
 151                                                         guint       old_status,
 152                                                         guint       new_status,
 153                                                         guint       reason,
 154                                                         gchar      *dbus_error_name,
 155                                                         GHashTable *details,
 156                                                         gpointer    user_data);
 157 static gboolean account_chooser_separator_func         (GtkTreeModel             *model,
 158                                                         GtkTreeIter              *iter,
 159                                                         EmpathyAccountChooser    *chooser);
 160 static gboolean account_chooser_set_account_foreach    (GtkTreeModel             *model,
 161                                                         GtkTreePath              *path,
 162                                                         GtkTreeIter              *iter,
 163                                                         SetAccountData           *data);
 164
 165 enum {
 166         PROP_0,
 167         PROP_HAS_ALL_OPTION,
 168 };
 169
 170 enum {
 171         READY,
 172         LAST_SIGNAL
 173 };
 174
 175 static guint signals[LAST_SIGNAL] = { 0 };
 176
 177 G_DEFINE_TYPE (EmpathyAccountChooser, empathy_account_chooser, GTK_TYPE_COMBO_BOX);
 178
 179 static void
 180 empathy_account_chooser_class_init (EmpathyAccountChooserClass *klass)
 181 {
 182         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 183
 184         object_class->constructed = account_chooser_constructed;
 185         object_class->finalize = account_chooser_finalize;
 186         object_class->get_property = account_chooser_get_property;
 187         object_class->set_property = account_chooser_set_property;
 188
 189         /**
 190          * EmpathyAccountChooser:has-all-option:
 191          *
 192          * Have an additional option in the list to mean all accounts.
 193          */
 194         g_object_class_install_property (object_class,
 195                                          PROP_HAS_ALL_OPTION,
 196                                          g_param_spec_boolean ("has-all-option",
 197                                                                "Has All Option",
 198                                                                "Have a separate option in the list to mean ALL accounts",
 199                                                                FALSE,
 200                                                                G_PARAM_READWRITE));
 201
 202         signals[READY] =
 203                 g_signal_new ("ready",
 204                               G_OBJECT_CLASS_TYPE (object_class),
 205                               G_SIGNAL_RUN_LAST,
 206                               0,
 207                               NULL, NULL,
 208                               g_cclosure_marshal_VOID__VOID,
 209                               G_TYPE_NONE,
 210                               0);
 211
 212         g_type_class_add_private (object_class, sizeof (EmpathyAccountChooserPriv));
 213 }
 214
 215 static void
 216 empathy_account_chooser_init (EmpathyAccountChooser *chooser)
 217 {
 218         EmpathyAccountChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
 219                 EMPATHY_TYPE_ACCOUNT_CHOOSER, EmpathyAccountChooserPriv);
 220
 221         chooser->priv = priv;
 222         priv->set_active_item = FALSE;
 223         priv->account_manually_set = FALSE;
 224         priv->filter = NULL;
 225         priv->filter_data = NULL;
 226
 227         priv->manager = tp_account_manager_dup ();
 228
 229         g_signal_connect (priv->manager, "account-validity-changed",
 230                           G_CALLBACK (account_chooser_account_validity_changed_cb),
 231                           chooser);
 232         g_signal_connect (priv->manager, "account-removed",
 233                           G_CALLBACK (account_chooser_account_removed_cb),
 234                           chooser);
 235 }
 236
 237 static void
 238 account_chooser_constructed (GObject *object)
 239 {
 240         EmpathyAccountChooser *self = (EmpathyAccountChooser *) object;
 241
 242         account_chooser_setup (self);
 243 }
 244
 245 static void
 246 account_chooser_finalize (GObject *object)
 247 {
 248         EmpathyAccountChooserPriv *priv = GET_PRIV (object);
 249
 250         g_signal_handlers_disconnect_by_func (priv->manager,
 251                                               account_chooser_account_validity_changed_cb,
 252                                               object);
 253         g_signal_handlers_disconnect_by_func (priv->manager,
 254                                               account_chooser_account_removed_cb,
 255                                               object);
 256         g_object_unref (priv->manager);
 257
 258         G_OBJECT_CLASS (empathy_account_chooser_parent_class)->finalize (object);
 259 }
 260
 261 static void
 262 account_chooser_get_property (GObject    *object,
 263                               guint       param_id,
 264                               GValue     *value,
 265                               GParamSpec *pspec)
 266 {
 267         EmpathyAccountChooserPriv *priv;
 268
 269         priv = GET_PRIV (object);
 270
 271         switch (param_id) {
 272         case PROP_HAS_ALL_OPTION:
 273                 g_value_set_boolean (value, priv->has_all_option);
 274                 break;
 275         default:
 276                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 277                 break;
 278         };
 279 }
 280
 281 static void
 282 account_chooser_set_property (GObject      *object,
 283                               guint         param_id,
 284                               const GValue *value,
 285                               GParamSpec   *pspec)
 286 {
 287         EmpathyAccountChooserPriv *priv;
 288
 289         priv = GET_PRIV (object);
 290
 291         switch (param_id) {
 292         case PROP_HAS_ALL_OPTION:
 293                 empathy_account_chooser_set_has_all_option (EMPATHY_ACCOUNT_CHOOSER (object),
 294                                                            g_value_get_boolean (value));
 295                 break;
 296         default:
 297                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 298                 break;
 299         };
 300 }
 301
 302 /**
 303  * empathy_account_chooser_new:
 304  *
 305  * Creates a new #EmpathyAccountChooser.
 306  *
 307  * Return value: A new #EmpathyAccountChooser
 308  */
 309 GtkWidget *
 310 empathy_account_chooser_new (void)
 311 {
 312         GtkWidget                *chooser;
 313
 314         chooser = g_object_new (EMPATHY_TYPE_ACCOUNT_CHOOSER, NULL);
 315
 316         return chooser;
 317 }
 318
 319 /**
 320  * empathy_account_chooser_dup_account:
 321  * @chooser: an #EmpathyAccountChooser
 322  *
 323  * Returns the account which is currently selected in the chooser or %NULL
 324  * if there is no account selected. The #TpAccount returned should be
 325  * unrefed with g_object_unref() when finished with.
 326  *
 327  * Return value: a new ref to the #TpAccount currently selected, or %NULL.
 328  */
 329 TpAccount *
 330 empathy_account_chooser_dup_account (EmpathyAccountChooser *chooser)
 331 {
 332         EmpathyAccountChooserPriv *priv;
 333         TpAccount                 *account;
 334         GtkTreeModel             *model;
 335         GtkTreeIter               iter;
 336
 337         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
 338
 339         priv = GET_PRIV (chooser);
 340
 341         model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser));
 342         if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (chooser), &iter)) {
 343                 return NULL;
 344         }
 345
 346         gtk_tree_model_get (model, &iter, COL_ACCOUNT_POINTER, &account, -1);
 347
 348         return account;
 349 }
 350
 351 /**
 352  * empathy_account_chooser_get_connection:
 353  * @chooser: an #EmpathyAccountChooser
 354  *
 355  * Returns a borrowed reference to the #TpConnection associated with the
 356  * account currently selected. The caller must reference the returned object with
 357  * g_object_ref() if it will be kept
 358  *
 359  * Return value: a borrowed reference to the #TpConnection associated with the
 360  * account curently selected.
 361  */
 362 TpConnection *
 363 empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
 364 {
 365         EmpathyAccountChooserPriv *priv;
 366         TpAccount                 *account;
 367         TpConnection              *connection;
 368
 369         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
 370
 371         priv = GET_PRIV (chooser);
 372
 373         account = empathy_account_chooser_dup_account (chooser);
 374
 375         /* if the returned account is NULL, then the account manager probably
 376          * hasn't been prepared yet. It should be safe to return NULL here
 377          * though. */
 378         if (account == NULL) {
 379                 return NULL;
 380         }
 381
 382         connection = tp_account_get_connection (account);
 383         g_object_unref (account);
 384
 385         return connection;
 386 }
 387
 388 /**
 389  * empathy_account_chooser_set_account:
 390  * @chooser: an #EmpathyAccountChooser
 391  * @account: a #TpAccount
 392  *
 393  * Sets the currently selected account to @account, if it exists in the list.
 394  *
 395  * Return value: whether the chooser was set to @account.
 396  */
 397 gboolean
 398 empathy_account_chooser_set_account (EmpathyAccountChooser *chooser,
 399                                      TpAccount             *account)
 400 {
 401         EmpathyAccountChooserPriv *priv;
 402         GtkComboBox    *combobox;
 403         GtkTreeModel   *model;
 404         GtkTreeIter     iter;
 405         SetAccountData  data;
 406
 407         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), FALSE);
 408
 409         priv = GET_PRIV (chooser);
 410
 411         combobox = GTK_COMBO_BOX (chooser);
 412         model = gtk_combo_box_get_model (combobox);
 413         gtk_combo_box_get_active_iter (combobox, &iter);
 414
 415         data.chooser = chooser;
 416         data.account = account;
 417
 418         gtk_tree_model_foreach (model,
 419                                 (GtkTreeModelForeachFunc) account_chooser_set_account_foreach,
 420                                 &data);
 421
 422         priv->account_manually_set = data.set;
 423
 424         return data.set;
 425 }
 426
 427 /**
 428  * empathy_account_chooser_get_has_all_option:
 429  * @chooser: an #EmpathyAccountChooser
 430  *
 431  * Returns whether @chooser has the #EmpathyAccountChooser:has-all-option property
 432  * set to true.
 433  *
 434  * Return value: whether @chooser has the #EmpathyAccountChooser:has-all-option property
 435  * enabled.
 436  */
 437 gboolean
 438 empathy_account_chooser_get_has_all_option (EmpathyAccountChooser *chooser)
 439 {
 440         EmpathyAccountChooserPriv *priv;
 441
 442         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), FALSE);
 443
 444         priv = GET_PRIV (chooser);
 445
 446         return priv->has_all_option;
 447 }
 448
 449 /**
 450  * empathy_account_chooser_set_has_all_option:
 451  * @chooser: an #EmpathyAccountChooser
 452  * @has_all_option: a new value for the #EmpathyAccountChooser:has-all-option property
 453  *
 454  * Sets the #EmpathyAccountChooser:has-all-option property.
 455  */
 456 void
 457 empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
 458                                            gboolean              has_all_option)
 459 {
 460         EmpathyAccountChooserPriv *priv;
 461         GtkComboBox              *combobox;
 462         GtkListStore             *store;
 463         GtkTreeModel             *model;
 464         GtkTreeIter               iter;
 465
 466         g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
 467
 468         priv = GET_PRIV (chooser);
 469
 470         if (priv->has_all_option == has_all_option) {
 471                 return;
 472         }
 473
 474         combobox = GTK_COMBO_BOX (chooser);
 475         model = gtk_combo_box_get_model (combobox);
 476         store = GTK_LIST_STORE (model);
 477
 478         priv->has_all_option = has_all_option;
 479
 480         /*
 481          * The first 2 options are the ALL and separator
 482          */
 483
 484         if (has_all_option) {
 485                 gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
 486                                                       (GtkTreeViewRowSeparatorFunc)
 487                                                       account_chooser_separator_func,
 488                                                       chooser,
 489                                                       NULL);
 490
 491                 gtk_list_store_prepend (store, &iter);
 492                 gtk_list_store_set (store, &iter,
 493                                     COL_ACCOUNT_TEXT, NULL,
 494                                     COL_ACCOUNT_ENABLED, TRUE,
 495                                     COL_ACCOUNT_POINTER, NULL,
 496                                     COL_ACCOUNT_ROW_TYPE, ROW_SEPARATOR,
 497                                     -1);
 498
 499                 gtk_list_store_prepend (store, &iter);
 500                 gtk_list_store_set (store, &iter,
 501                                     COL_ACCOUNT_TEXT, _("All"),
 502                                     COL_ACCOUNT_ENABLED, TRUE,
 503                                     COL_ACCOUNT_POINTER, NULL,
 504                                     COL_ACCOUNT_ROW_TYPE, ROW_ALL,
 505                                     -1);
 506         } else {
 507                 if (gtk_tree_model_get_iter_first (model, &iter)) {
 508                         if (gtk_list_store_remove (GTK_LIST_STORE (model), &iter)) {
 509                                 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 510                         }
 511                 }
 512
 513                 gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
 514                                                       (GtkTreeViewRowSeparatorFunc)
 515                                                       NULL,
 516                                                       NULL,
 517                                                       NULL);
 518         }
 519
 520         g_object_notify (G_OBJECT (chooser), "has-all-option");
 521 }
 522
 523 static void
 524 account_manager_prepared_cb (GObject *source_object,
 525                              GAsyncResult *result,
 526                              gpointer user_data)
 527 {
 528         GList *accounts, *l;
 529         TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
 530         EmpathyAccountChooser *chooser = user_data;
 531         EmpathyAccountChooserPriv *priv = GET_PRIV (chooser);
 532         GError *error = NULL;
 533
 534         if (!tp_account_manager_prepare_finish (manager, result, &error)) {
 535                 DEBUG ("Failed to prepare account manager: %s", error->message);
 536                 g_error_free (error);
 537                 return;
 538         }
 539
 540         accounts = tp_account_manager_get_valid_accounts (manager);
 541
 542         for (l = accounts; l != NULL; l = l->next) {
 543                 TpAccount *account = l->data;
 544
 545                 account_chooser_account_add_foreach (account, chooser);
 546
 547                 tp_g_signal_connect_object (account, "status-changed",
 548                                              G_CALLBACK (account_chooser_status_changed_cb),
 549                                              chooser, 0);
 550         }
 551
 552         g_list_free (accounts);
 553
 554         priv->ready = TRUE;
 555         g_signal_emit (chooser, signals[READY], 0);
 556 }
 557
 558 static gint
 559 account_cmp (GtkTreeModel *model,
 560              GtkTreeIter *a,
 561              GtkTreeIter *b,
 562              gpointer user_data)
 563 {
 564         RowType a_type, b_type;
 565         gboolean a_enabled, b_enabled;
 566         gchar *a_text, *b_text;
 567         gint result;
 568
 569         gtk_tree_model_get (model, a,
 570                 COL_ACCOUNT_ENABLED, &a_enabled,
 571                 COL_ACCOUNT_ROW_TYPE, &a_type,
 572                 -1);
 573         gtk_tree_model_get (model, b,
 574                 COL_ACCOUNT_ENABLED, &b_enabled,
 575                 COL_ACCOUNT_ROW_TYPE, &b_type,
 576                 -1);
 577
 578         /* This assumes that we have at most one of each special row type. */
 579         if (a_type != b_type) {
 580                 /* Display higher-numbered special row types first. */
 581                 return (b_type - a_type);
 582         }
 583
 584         /* Enabled accounts are displayed first */
 585         if (a_enabled != b_enabled)
 586                 return a_enabled ? -1: 1;
 587
 588         gtk_tree_model_get (model, a, COL_ACCOUNT_TEXT, &a_text, -1);
 589         gtk_tree_model_get (model, b, COL_ACCOUNT_TEXT, &b_text, -1);
 590
 591         if (a_text == b_text)
 592                 result = 0;
 593         else if (a_text == NULL)
 594                 result = 1;
 595         else if (b_text == NULL)
 596                 result = -1;
 597         else
 598                 result = g_ascii_strcasecmp (a_text, b_text);
 599
 600         g_free (a_text);
 601         g_free (b_text);
 602
 603         return result;
 604 }
 605
 606 static void
 607 account_chooser_setup (EmpathyAccountChooser *chooser)
 608 {
 609         EmpathyAccountChooserPriv *priv;
 610         GtkListStore             *store;
 611         GtkCellRenderer          *renderer;
 612         GtkComboBox              *combobox;
 613
 614         priv = GET_PRIV (chooser);
 615
 616         /* Set up combo box with new store */
 617         combobox = GTK_COMBO_BOX (chooser);
 618
 619         gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
 620
 621         store = gtk_list_store_new (COL_ACCOUNT_COUNT,
 622                                     G_TYPE_STRING,    /* Image */
 623                                     G_TYPE_STRING,    /* Name */
 624                                     G_TYPE_BOOLEAN,   /* Enabled */
 625                                     G_TYPE_UINT,      /* Row type */
 626                                     TP_TYPE_ACCOUNT);
 627
 628         gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
 629                 account_cmp, chooser, NULL);
 630         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
 631                 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 632
 633         gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
 634
 635         renderer = gtk_cell_renderer_pixbuf_new ();
 636         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
 637         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
 638                                         "icon-name", COL_ACCOUNT_IMAGE,
 639                                         "sensitive", COL_ACCOUNT_ENABLED,
 640                                         NULL);
 641         g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
 642
 643         renderer = gtk_cell_renderer_text_new ();
 644         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
 645         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
 646                                         "text", COL_ACCOUNT_TEXT,
 647                                         "sensitive", COL_ACCOUNT_ENABLED,
 648                                         NULL);
 649
 650         /* Populate accounts */
 651         tp_account_manager_prepare_async (priv->manager, NULL,
 652                                           account_manager_prepared_cb, chooser);
 653
 654         g_object_unref (store);
 655 }
 656
 657 static void
 658 account_chooser_account_validity_changed_cb (TpAccountManager      *manager,
 659                                              TpAccount             *account,
 660                                              gboolean               valid,
 661                                              EmpathyAccountChooser *chooser)
 662 {
 663         if (valid) {
 664                 account_chooser_account_add_foreach (account, chooser);
 665         } else {
 666                 account_chooser_account_remove_foreach (account, chooser);
 667         }
 668 }
 669
 670 static void
 671 account_chooser_account_add_foreach (TpAccount             *account,
 672                                      EmpathyAccountChooser *chooser)
 673 {
 674         GtkListStore *store;
 675         GtkComboBox  *combobox;
 676         GtkTreeIter   iter;
 677         gint          position;
 678
 679         combobox = GTK_COMBO_BOX (chooser);
 680         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 681
 682         position = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL);
 683         gtk_list_store_insert_with_values (store, &iter, position,
 684                                            COL_ACCOUNT_POINTER, account,
 685                                            -1);
 686         account_chooser_update_iter (chooser, &iter);
 687 }
 688
 689 static void
 690 account_chooser_account_removed_cb (TpAccountManager      *manager,
 691                                     TpAccount             *account,
 692                                     EmpathyAccountChooser *chooser)
 693 {
 694         account_chooser_account_remove_foreach (account, chooser);
 695 }
 696
 697 typedef struct {
 698         TpAccount   *account;
 699         GtkTreeIter *iter;
 700         gboolean     found;
 701 } FindAccountData;
 702
 703 static gboolean
 704 account_chooser_find_account_foreach (GtkTreeModel *model,
 705                                       GtkTreePath  *path,
 706                                       GtkTreeIter  *iter,
 707                                       gpointer      user_data)
 708 {
 709         FindAccountData *data = user_data;
 710         TpAccount  *account;
 711
 712         gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
 713
 714         if (account == data->account) {
 715                 data->found = TRUE;
 716                 *(data->iter) = *iter;
 717                 g_object_unref (account);
 718
 719                 return TRUE;
 720         }
 721
 722         g_object_unref (account);
 723
 724         return FALSE;
 725 }
 726
 727 static gboolean
 728 account_chooser_find_account (EmpathyAccountChooser *chooser,
 729                               TpAccount             *account,
 730                               GtkTreeIter           *iter)
 731 {
 732         GtkListStore    *store;
 733         GtkComboBox     *combobox;
 734         FindAccountData  data;
 735
 736         combobox = GTK_COMBO_BOX (chooser);
 737         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 738
 739         data.account = account;
 740         data.iter = iter;
 741         gtk_tree_model_foreach (GTK_TREE_MODEL (store),
 742                                 account_chooser_find_account_foreach,
 743                                 &data);
 744
 745         return data.found;
 746 }
 747
 748 static void
 749 account_chooser_account_remove_foreach (TpAccount             *account,
 750                                         EmpathyAccountChooser *chooser)
 751 {
 752         GtkListStore *store;
 753         GtkComboBox  *combobox;
 754         GtkTreeIter   iter;
 755
 756         combobox = GTK_COMBO_BOX (chooser);
 757         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 758
 759         if (account_chooser_find_account (chooser, account, &iter)) {
 760                 gtk_list_store_remove (store, &iter);
 761         }
 762 }
 763
 764 static void
 765 account_chooser_filter_ready_cb (gboolean is_enabled,
 766                                  gpointer data)
 767 {
 768         FilterResultCallbackData  *fr_data = data;
 769         EmpathyAccountChooser     *chooser;
 770         EmpathyAccountChooserPriv *priv;
 771         TpAccount                 *account;
 772         GtkTreeIter               *iter;
 773         GtkListStore              *store;
 774         GtkComboBox               *combobox;
 775         const gchar               *icon_name;
 776
 777         chooser = fr_data->chooser;
 778         priv = GET_PRIV (chooser);
 779         account = fr_data->account;
 780         iter = fr_data->iter;
 781         combobox = GTK_COMBO_BOX (chooser);
 782         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 783
 784         icon_name = tp_account_get_icon_name (account);
 785
 786         gtk_list_store_set (store, iter,
 787                             COL_ACCOUNT_IMAGE, icon_name,
 788                             COL_ACCOUNT_TEXT, tp_account_get_display_name (account),
 789                             COL_ACCOUNT_ENABLED, is_enabled,
 790                             -1);
 791
 792         /* set first connected account as active account */
 793         if (priv->account_manually_set == FALSE &&
 794             priv->set_active_item == FALSE && is_enabled) {
 795                 priv->set_active_item = TRUE;
 796                 gtk_combo_box_set_active_iter (combobox, iter);
 797         }
 798
 799         g_object_unref (account);
 800         filter_result_callback_data_free (fr_data);
 801 }
 802
 803 static void
 804 account_chooser_update_iter (EmpathyAccountChooser *chooser,
 805                              GtkTreeIter           *iter)
 806 {
 807         EmpathyAccountChooserPriv *priv;
 808         GtkListStore              *store;
 809         GtkComboBox               *combobox;
 810         TpAccount                 *account;
 811         FilterResultCallbackData  *data;
 812
 813         priv = GET_PRIV (chooser);
 814
 815         combobox = GTK_COMBO_BOX (chooser);
 816         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 817
 818         gtk_tree_model_get (GTK_TREE_MODEL (store), iter,
 819                             COL_ACCOUNT_POINTER, &account,
 820                             -1);
 821
 822         /* Skip rows without account associated */
 823         if (account == NULL)
 824                 return;
 825
 826         data = filter_result_callback_data_new (chooser, account, iter);
 827
 828         if (priv->filter)
 829                 priv->filter (account, account_chooser_filter_ready_cb,
 830                               (gpointer) data, priv->filter_data);
 831         else
 832                 account_chooser_filter_ready_cb (TRUE, (gpointer) data);
 833 }
 834
 835 static void
 836 account_chooser_status_changed_cb (TpAccount  *account,
 837                                    guint       old_status,
 838                                    guint       new_status,
 839                                    guint       reason,
 840                                    gchar      *dbus_error_name,
 841                                    GHashTable *details,
 842                                    gpointer    user_data)
 843 {
 844         EmpathyAccountChooser *chooser = user_data;
 845         GtkTreeIter iter;
 846
 847         if (account_chooser_find_account (chooser, account, &iter)) {
 848                 account_chooser_update_iter (chooser, &iter);
 849         }
 850 }
 851
 852 static gboolean
 853 account_chooser_separator_func (GtkTreeModel         *model,
 854                                 GtkTreeIter          *iter,
 855                                 EmpathyAccountChooser *chooser)
 856 {
 857         RowType row_type;
 858
 859         gtk_tree_model_get (model, iter, COL_ACCOUNT_ROW_TYPE, &row_type, -1);
 860         return (row_type == ROW_SEPARATOR);
 861 }
 862
 863 static gboolean
 864 account_chooser_set_account_foreach (GtkTreeModel   *model,
 865                                      GtkTreePath    *path,
 866                                      GtkTreeIter    *iter,
 867                                      SetAccountData *data)
 868 {
 869         TpAccount *account;
 870         gboolean   equal;
 871
 872         gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
 873
 874         equal = (data->account == account);
 875
 876         if (account) {
 877                 g_object_unref (account);
 878         }
 879
 880         if (equal) {
 881                 GtkComboBox *combobox;
 882
 883                 combobox = GTK_COMBO_BOX (data->chooser);
 884                 gtk_combo_box_set_active_iter (combobox, iter);
 885
 886                 data->set = TRUE;
 887         }
 888
 889         return equal;
 890 }
 891
 892 static gboolean
 893 account_chooser_filter_foreach (GtkTreeModel *model,
 894                                 GtkTreePath  *path,
 895                                 GtkTreeIter  *iter,
 896                                 gpointer      chooser)
 897 {
 898         account_chooser_update_iter (chooser, iter);
 899         return FALSE;
 900 }
 901
 902 /**
 903  * empathy_account_chooser_set_filter:
 904  * @chooser: an #EmpathyAccountChooser
 905  * @filter: a filter
 906  * @user_data: data to pass to @filter, or %NULL
 907  *
 908  * Sets a filter on the @chooser so only accounts that are %TRUE in the eyes
 909  * of the filter are visible in the @chooser.
 910  */
 911 void
 912 empathy_account_chooser_set_filter (EmpathyAccountChooser           *chooser,
 913                                     EmpathyAccountChooserFilterFunc  filter,
 914                                     gpointer                         user_data)
 915 {
 916         EmpathyAccountChooserPriv *priv;
 917         GtkTreeModel *model;
 918
 919         g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
 920
 921         priv = GET_PRIV (chooser);
 922
 923         priv->filter = filter;
 924         priv->filter_data = user_data;
 925
 926         /* Refilter existing data */
 927         priv->set_active_item = FALSE;
 928         model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser));
 929         gtk_tree_model_foreach (model, account_chooser_filter_foreach, chooser);
 930 }
 931
 932 /**
 933  * EmpathyAccountChooserFilterFunc:
 934  * @account: a #TpAccount
 935  * @user_data: user data, or %NULL
 936  *
 937  * A function which decides whether the account indicated by @account
 938  * is visible.
 939  *
 940  * Return value: whether the account indicated by @account is visible.
 941  */
 942
 943 /**
 944  * empathy_account_chooser_filter_is_connected:
 945  * @account: a #TpAccount
 946  * @callback: an #EmpathyAccountChooserFilterResultCallback accepting the result
 947  * @callback_data: data passed to the @callback
 948  * @user_data: user data or %NULL
 949  *
 950  * A useful #EmpathyAccountChooserFilterFunc that one could pass into
 951  * empathy_account_chooser_set_filter() and only show connected accounts.
 952  *
 953  * Returns (via the callback) TRUE is @account is connected
 954  */
 955 void
 956 empathy_account_chooser_filter_is_connected (
 957         TpAccount                                 *account,
 958         EmpathyAccountChooserFilterResultCallback  callback,
 959         gpointer                                   callback_data,
 960         gpointer                                   user_data)
 961 {
 962         gboolean is_connected =
 963                 tp_account_get_connection_status (account, NULL)
 964                 == TP_CONNECTION_STATUS_CONNECTED;
 965         callback (is_connected, callback_data);
 966 }
 967
 968 typedef struct {
 969         EmpathyAccountChooserFilterResultCallback callback;
 970         gpointer                                  user_data;
 971 } FilterCallbackData;
 972
 973 static void
 974 conn_prepared_cb (GObject *conn,
 975                 GAsyncResult *result,
 976                 gpointer user_data)
 977 {
 978         FilterCallbackData *data = user_data;
 979         GError             *myerr = NULL;
 980         TpCapabilities     *caps;
 981
 982         if (!tp_proxy_prepare_finish (conn, result, &myerr)) {
 983                 data->callback (FALSE, data->user_data);
 984                 g_slice_free (FilterCallbackData, data);
 985                 return;
 986         }
 987
 988         caps = tp_connection_get_capabilities (TP_CONNECTION (conn));
 989         data->callback (tp_capabilities_supports_text_chatrooms (caps),
 990                         data->user_data);
 991
 992         g_slice_free (FilterCallbackData, data);
 993 }
 994
 995 /**
 996  * empathy_account_chooser_filter_supports_multichat:
 997  * @account: a #TpAccount
 998  * @callback: an #EmpathyAccountChooserFilterResultCallback accepting the result
 999  * @callback_data: data passed to the @callback
1000  * @user_data: user data or %NULL
1001  *
1002  * An #EmpathyAccountChooserFilterFunc that returns accounts that both
1003  * support multiuser text chat and are connected.
1004  *
1005  * Returns (via the callback) TRUE if @account both supports muc and is connected
1006  */
1007 void
1008 empathy_account_chooser_filter_supports_chatrooms (
1009         TpAccount                                 *account,
1010         EmpathyAccountChooserFilterResultCallback  callback,
1011         gpointer                                   callback_data,
1012         gpointer                                   user_data)
1013 {
1014         TpConnection       *connection;
1015         FilterCallbackData *cb_data;
1016         GQuark              features[] = { TP_CONNECTION_FEATURE_CAPABILITIES, 0 };
1017
1018         if (tp_account_get_connection_status (account, NULL) !=
1019                 TP_CONNECTION_STATUS_CONNECTED) {
1020                 callback (FALSE, callback_data);
1021                 return;
1022         }
1023
1024         /* check if CM supports multiuser text chat */
1025         connection = tp_account_get_connection (account);
1026         if (connection == NULL) {
1027                 callback (FALSE, callback_data);
1028                 return;
1029         }
1030
1031         cb_data = g_slice_new0 (FilterCallbackData);
1032         cb_data->callback = callback;
1033         cb_data->user_data = callback_data;
1034
1035         tp_proxy_prepare_async (connection, features, conn_prepared_cb,
1036                 cb_data);
1037 }
1038
1039 gboolean
1040 empathy_account_chooser_is_ready (EmpathyAccountChooser *self)
1041 {
1042         EmpathyAccountChooserPriv *priv = GET_PRIV (self);
1043
1044         return priv->ready;
1045 }
1046
1047 TpAccount *
1048 empathy_account_chooser_get_account (EmpathyAccountChooser *chooser)
1049 {
1050         TpAccount *account;
1051
1052         account = empathy_account_chooser_dup_account (chooser);
1053         if (account == NULL)
1054                 return NULL;
1055
1056         g_object_unref (account);
1057
1058         return account;
1059 }