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
  34 #include <libempathy/empathy-utils.h>
  35
  36 #include "empathy-ui-utils.h"
  37 #include "empathy-account-chooser.h"
  38
  39 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  40 #include <libempathy/empathy-debug.h>
  41
  42 /**
  43  * SECTION:empathy-account-chooser
  44  * @title:EmpathyAccountChooser
  45  * @short_description: A widget used to choose from a list of accounts
  46  * @include: libempathy-gtk/empathy-account-chooser.h
  47  *
  48  * #EmpathyAccountChooser is a widget which extends #GtkComboBox to provide
  49  * a chooser of available accounts.
  50  */
  51
  52 /**
  53  * EmpathyAccountChooser:
  54  * @parent: parent object
  55  *
  56  * Widget which extends #GtkComboBox to provide a chooser of available accounts.
  57  */
  58
  59 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyAccountChooser)
  60 typedef struct {
  61         TpAccountManager               *manager;
  62         gboolean                        set_active_item;
  63         gboolean                        account_manually_set;
  64         gboolean                        has_all_option;
  65         EmpathyAccountChooserFilterFunc filter;
  66         gpointer                        filter_data;
  67         gboolean                        ready;
  68 } EmpathyAccountChooserPriv;
  69
  70 typedef struct {
  71         EmpathyAccountChooser *chooser;
  72         TpAccount             *account;
  73         gboolean               set;
  74 } SetAccountData;
  75
  76 enum {
  77         COL_ACCOUNT_IMAGE,
  78         COL_ACCOUNT_TEXT,
  79         COL_ACCOUNT_ENABLED, /* Usually tied to connected state */
  80         COL_ACCOUNT_POINTER,
  81         COL_ACCOUNT_COUNT
  82 };
  83
  84 static void     account_chooser_finalize               (GObject                  *object);
  85 static void     account_chooser_get_property           (GObject                  *object,
  86                                                         guint                     param_id,
  87                                                         GValue                   *value,
  88                                                         GParamSpec               *pspec);
  89 static void     account_chooser_set_property           (GObject                  *object,
  90                                                         guint                     param_id,
  91                                                         const GValue             *value,
  92                                                         GParamSpec               *pspec);
  93 static void     account_chooser_setup                  (EmpathyAccountChooser    *chooser);
  94 static void     account_chooser_account_validity_changed_cb (TpAccountManager    *manager,
  95                                                         TpAccount                *account,
  96                                                         gboolean                  valid,
  97                                                         EmpathyAccountChooser    *chooser);
  98 static void     account_chooser_account_add_foreach    (TpAccount                *account,
  99                                                         EmpathyAccountChooser    *chooser);
 100 static void     account_chooser_account_removed_cb     (TpAccountManager         *manager,
 101                                                         TpAccount                *account,
 102                                                         EmpathyAccountChooser    *chooser);
 103 static void     account_chooser_account_remove_foreach (TpAccount                *account,
 104                                                         EmpathyAccountChooser    *chooser);
 105 static void     account_chooser_update_iter            (EmpathyAccountChooser    *chooser,
 106                                                         GtkTreeIter              *iter);
 107 static void     account_chooser_status_changed_cb      (TpAccount  *account,
 108                                                         guint       old_status,
 109                                                         guint       new_status,
 110                                                         guint       reason,
 111                                                         gchar      *dbus_error_name,
 112                                                         GHashTable *details,
 113                                                         gpointer    user_data);
 114 static gboolean account_chooser_separator_func         (GtkTreeModel             *model,
 115                                                         GtkTreeIter              *iter,
 116                                                         EmpathyAccountChooser    *chooser);
 117 static gboolean account_chooser_set_account_foreach    (GtkTreeModel             *model,
 118                                                         GtkTreePath              *path,
 119                                                         GtkTreeIter              *iter,
 120                                                         SetAccountData           *data);
 121
 122 enum {
 123         PROP_0,
 124         PROP_HAS_ALL_OPTION,
 125 };
 126
 127 enum {
 128         READY,
 129         LAST_SIGNAL
 130 };
 131
 132 static guint signals[LAST_SIGNAL] = { 0 };
 133
 134 G_DEFINE_TYPE (EmpathyAccountChooser, empathy_account_chooser, GTK_TYPE_COMBO_BOX);
 135
 136 static void
 137 empathy_account_chooser_class_init (EmpathyAccountChooserClass *klass)
 138 {
 139         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 140
 141         object_class->finalize = account_chooser_finalize;
 142         object_class->get_property = account_chooser_get_property;
 143         object_class->set_property = account_chooser_set_property;
 144
 145         /**
 146          * EmpathyAccountChooser:has-all-option:
 147          *
 148          * Have an additional option in the list to mean all accounts.
 149          */
 150         g_object_class_install_property (object_class,
 151                                          PROP_HAS_ALL_OPTION,
 152                                          g_param_spec_boolean ("has-all-option",
 153                                                                "Has All Option",
 154                                                                "Have a separate option in the list to mean ALL accounts",
 155                                                                FALSE,
 156                                                                G_PARAM_READWRITE));
 157
 158         signals[READY] =
 159                 g_signal_new ("ready",
 160                               G_OBJECT_CLASS_TYPE (object_class),
 161                               G_SIGNAL_RUN_LAST,
 162                               0,
 163                               NULL, NULL,
 164                               g_cclosure_marshal_VOID__VOID,
 165                               G_TYPE_NONE,
 166                               0);
 167
 168         g_type_class_add_private (object_class, sizeof (EmpathyAccountChooserPriv));
 169 }
 170
 171 static void
 172 empathy_account_chooser_init (EmpathyAccountChooser *chooser)
 173 {
 174         EmpathyAccountChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
 175                 EMPATHY_TYPE_ACCOUNT_CHOOSER, EmpathyAccountChooserPriv);
 176
 177         chooser->priv = priv;
 178         priv->set_active_item = FALSE;
 179         priv->account_manually_set = FALSE;
 180         priv->filter = NULL;
 181         priv->filter_data = NULL;
 182
 183         priv->manager = tp_account_manager_dup ();
 184
 185         g_signal_connect (priv->manager, "account-validity-changed",
 186                           G_CALLBACK (account_chooser_account_validity_changed_cb),
 187                           chooser);
 188         g_signal_connect (priv->manager, "account-removed",
 189                           G_CALLBACK (account_chooser_account_removed_cb),
 190                           chooser);
 191
 192         account_chooser_setup (EMPATHY_ACCOUNT_CHOOSER (chooser));
 193 }
 194
 195 static void
 196 account_chooser_finalize (GObject *object)
 197 {
 198         EmpathyAccountChooserPriv *priv = GET_PRIV (object);
 199
 200         g_signal_handlers_disconnect_by_func (priv->manager,
 201                                               account_chooser_account_validity_changed_cb,
 202                                               object);
 203         g_signal_handlers_disconnect_by_func (priv->manager,
 204                                               account_chooser_account_removed_cb,
 205                                               object);
 206         g_object_unref (priv->manager);
 207
 208         G_OBJECT_CLASS (empathy_account_chooser_parent_class)->finalize (object);
 209 }
 210
 211 static void
 212 account_chooser_get_property (GObject    *object,
 213                               guint       param_id,
 214                               GValue     *value,
 215                               GParamSpec *pspec)
 216 {
 217         EmpathyAccountChooserPriv *priv;
 218
 219         priv = GET_PRIV (object);
 220
 221         switch (param_id) {
 222         case PROP_HAS_ALL_OPTION:
 223                 g_value_set_boolean (value, priv->has_all_option);
 224                 break;
 225         default:
 226                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 227                 break;
 228         };
 229 }
 230
 231 static void
 232 account_chooser_set_property (GObject      *object,
 233                               guint         param_id,
 234                               const GValue *value,
 235                               GParamSpec   *pspec)
 236 {
 237         EmpathyAccountChooserPriv *priv;
 238
 239         priv = GET_PRIV (object);
 240
 241         switch (param_id) {
 242         case PROP_HAS_ALL_OPTION:
 243                 empathy_account_chooser_set_has_all_option (EMPATHY_ACCOUNT_CHOOSER (object),
 244                                                            g_value_get_boolean (value));
 245                 break;
 246         default:
 247                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 248                 break;
 249         };
 250 }
 251
 252 /**
 253  * empathy_account_chooser_new:
 254  *
 255  * Creates a new #EmpathyAccountChooser.
 256  *
 257  * Return value: A new #EmpathyAccountChooser
 258  */
 259 GtkWidget *
 260 empathy_account_chooser_new (void)
 261 {
 262         GtkWidget                *chooser;
 263
 264         chooser = g_object_new (EMPATHY_TYPE_ACCOUNT_CHOOSER, NULL);
 265
 266         return chooser;
 267 }
 268
 269 /**
 270  * empathy_account_chooser_dup_account:
 271  * @chooser: an #EmpathyAccountChooser
 272  *
 273  * Returns the account which is currently selected in the chooser or %NULL
 274  * if there is no account selected. The #TpAccount returned should be
 275  * unrefed with g_object_unref() when finished with.
 276  *
 277  * Return value: a new ref to the #TpAccount currently selected, or %NULL.
 278  */
 279 TpAccount *
 280 empathy_account_chooser_dup_account (EmpathyAccountChooser *chooser)
 281 {
 282         EmpathyAccountChooserPriv *priv;
 283         TpAccount                 *account;
 284         GtkTreeModel             *model;
 285         GtkTreeIter               iter;
 286
 287         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
 288
 289         priv = GET_PRIV (chooser);
 290
 291         model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser));
 292         if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (chooser), &iter)) {
 293                 return NULL;
 294         }
 295
 296         gtk_tree_model_get (model, &iter, COL_ACCOUNT_POINTER, &account, -1);
 297
 298         return account;
 299 }
 300
 301 /**
 302  * empathy_account_chooser_get_connection:
 303  * @chooser: an #EmpathyAccountChooser
 304  *
 305  * Returns a borrowed reference to the #TpConnection associated with the
 306  * account currently selected. The caller must reference the returned object with
 307  * g_object_ref() if it will be kept
 308  *
 309  * Return value: a borrowed reference to the #TpConnection associated with the
 310  * account curently selected.
 311  */
 312 TpConnection *
 313 empathy_account_chooser_get_connection (EmpathyAccountChooser *chooser)
 314 {
 315         EmpathyAccountChooserPriv *priv;
 316         TpAccount                 *account;
 317         TpConnection              *connection;
 318
 319         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), NULL);
 320
 321         priv = GET_PRIV (chooser);
 322
 323         account = empathy_account_chooser_dup_account (chooser);
 324
 325         /* if the returned account is NULL, then the account manager probably
 326          * hasn't been prepared yet. It should be safe to return NULL here
 327          * though. */
 328         if (account == NULL) {
 329                 return NULL;
 330         }
 331
 332         connection = tp_account_get_connection (account);
 333         g_object_unref (account);
 334
 335         return connection;
 336 }
 337
 338 /**
 339  * empathy_account_chooser_set_account:
 340  * @chooser: an #EmpathyAccountChooser
 341  * @account: a #TpAccount
 342  *
 343  * Sets the currently selected account to @account, if it exists in the list.
 344  *
 345  * Return value: whether the chooser was set to @account.
 346  */
 347 gboolean
 348 empathy_account_chooser_set_account (EmpathyAccountChooser *chooser,
 349                                      TpAccount             *account)
 350 {
 351         EmpathyAccountChooserPriv *priv;
 352         GtkComboBox    *combobox;
 353         GtkTreeModel   *model;
 354         GtkTreeIter     iter;
 355         SetAccountData  data;
 356
 357         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), FALSE);
 358
 359         priv = GET_PRIV (chooser);
 360
 361         combobox = GTK_COMBO_BOX (chooser);
 362         model = gtk_combo_box_get_model (combobox);
 363         gtk_combo_box_get_active_iter (combobox, &iter);
 364
 365         data.chooser = chooser;
 366         data.account = account;
 367
 368         gtk_tree_model_foreach (model,
 369                                 (GtkTreeModelForeachFunc) account_chooser_set_account_foreach,
 370                                 &data);
 371
 372         priv->account_manually_set = data.set;
 373
 374         return data.set;
 375 }
 376
 377 /**
 378  * empathy_account_chooser_get_has_all_option:
 379  * @chooser: an #EmpathyAccountChooser
 380  *
 381  * Returns whether @chooser has the #EmpathyAccountChooser:has-all-option property
 382  * set to true.
 383  *
 384  * Return value: whether @chooser has the #EmpathyAccountChooser:has-all-option property
 385  * enabled.
 386  */
 387 gboolean
 388 empathy_account_chooser_get_has_all_option (EmpathyAccountChooser *chooser)
 389 {
 390         EmpathyAccountChooserPriv *priv;
 391
 392         g_return_val_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser), FALSE);
 393
 394         priv = GET_PRIV (chooser);
 395
 396         return priv->has_all_option;
 397 }
 398
 399 /**
 400  * empathy_account_chooser_set_has_all_option:
 401  * @chooser: an #EmpathyAccountChooser
 402  * @has_all_option: a new value for the #EmpathyAccountChooser:has-all-option property
 403  *
 404  * Sets the #EmpathyAccountChooser:has-all-option property.
 405  */
 406 void
 407 empathy_account_chooser_set_has_all_option (EmpathyAccountChooser *chooser,
 408                                            gboolean              has_all_option)
 409 {
 410         EmpathyAccountChooserPriv *priv;
 411         GtkComboBox              *combobox;
 412         GtkListStore             *store;
 413         GtkTreeModel             *model;
 414         GtkTreeIter               iter;
 415
 416         g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
 417
 418         priv = GET_PRIV (chooser);
 419
 420         if (priv->has_all_option == has_all_option) {
 421                 return;
 422         }
 423
 424         combobox = GTK_COMBO_BOX (chooser);
 425         model = gtk_combo_box_get_model (combobox);
 426         store = GTK_LIST_STORE (model);
 427
 428         priv->has_all_option = has_all_option;
 429
 430         /*
 431          * The first 2 options are the ALL and separator
 432          */
 433
 434         if (has_all_option) {
 435                 gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
 436                                                       (GtkTreeViewRowSeparatorFunc)
 437                                                       account_chooser_separator_func,
 438                                                       chooser,
 439                                                       NULL);
 440
 441                 gtk_list_store_prepend (store, &iter);
 442                 gtk_list_store_set (store, &iter,
 443                                     COL_ACCOUNT_TEXT, NULL,
 444                                     COL_ACCOUNT_ENABLED, TRUE,
 445                                     COL_ACCOUNT_POINTER, NULL,
 446                                     -1);
 447
 448                 gtk_list_store_prepend (store, &iter);
 449                 gtk_list_store_set (store, &iter,
 450                                     COL_ACCOUNT_TEXT, _("All"),
 451                                     COL_ACCOUNT_ENABLED, TRUE,
 452                                     COL_ACCOUNT_POINTER, NULL,
 453                                     -1);
 454         } else {
 455                 if (gtk_tree_model_get_iter_first (model, &iter)) {
 456                         if (gtk_list_store_remove (GTK_LIST_STORE (model), &iter)) {
 457                                 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
 458                         }
 459                 }
 460
 461                 gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (chooser),
 462                                                       (GtkTreeViewRowSeparatorFunc)
 463                                                       NULL,
 464                                                       NULL,
 465                                                       NULL);
 466         }
 467
 468         g_object_notify (G_OBJECT (chooser), "has-all-option");
 469 }
 470
 471 static void
 472 account_manager_prepared_cb (GObject *source_object,
 473                              GAsyncResult *result,
 474                              gpointer user_data)
 475 {
 476         GList *accounts, *l;
 477         TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
 478         EmpathyAccountChooser *chooser = user_data;
 479         EmpathyAccountChooserPriv *priv = GET_PRIV (chooser);
 480         GError *error = NULL;
 481
 482         if (!tp_account_manager_prepare_finish (manager, result, &error)) {
 483                 DEBUG ("Failed to prepare account manager: %s", error->message);
 484                 g_error_free (error);
 485                 return;
 486         }
 487
 488         accounts = tp_account_manager_get_valid_accounts (manager);
 489
 490         for (l = accounts; l != NULL; l = l->next) {
 491                 TpAccount *account = l->data;
 492
 493                 account_chooser_account_add_foreach (account, chooser);
 494
 495                 empathy_signal_connect_weak (account, "status-changed",
 496                                              G_CALLBACK (account_chooser_status_changed_cb),
 497                                              G_OBJECT (chooser));
 498         }
 499
 500         g_list_free (accounts);
 501
 502         priv->ready = TRUE;
 503         g_signal_emit (chooser, signals[READY], 0);
 504 }
 505
 506 static gint
 507 account_cmp (GtkTreeModel *model,
 508              GtkTreeIter *a,
 509              GtkTreeIter *b,
 510              gpointer user_data)
 511 {
 512         gboolean a_enabled, b_enabled;
 513         gchar *a_text, *b_text;
 514         gint result;
 515
 516         gtk_tree_model_get (model, a, COL_ACCOUNT_ENABLED, &a_enabled, -1);
 517         gtk_tree_model_get (model, b, COL_ACCOUNT_ENABLED, &b_enabled, -1);
 518
 519         /* Enabled accounts are displayed first */
 520         if (a_enabled != b_enabled)
 521                 return a_enabled ? -1: 1;
 522
 523         gtk_tree_model_get (model, a, COL_ACCOUNT_TEXT, &a_text, -1);
 524         gtk_tree_model_get (model, b, COL_ACCOUNT_TEXT, &b_text, -1);
 525
 526         if (a_text == b_text)
 527                 result = 0;
 528         else if (a_text == NULL)
 529                 result = 1;
 530         else if (b_text == NULL)
 531                 result = -1;
 532         else
 533                 result = g_ascii_strcasecmp (a_text, b_text);
 534
 535         g_free (a_text);
 536         g_free (b_text);
 537
 538         return result;
 539 }
 540
 541 static void
 542 account_chooser_setup (EmpathyAccountChooser *chooser)
 543 {
 544         EmpathyAccountChooserPriv *priv;
 545         GtkListStore             *store;
 546         GtkCellRenderer          *renderer;
 547         GtkComboBox              *combobox;
 548
 549         priv = GET_PRIV (chooser);
 550
 551         /* Set up combo box with new store */
 552         combobox = GTK_COMBO_BOX (chooser);
 553
 554         gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
 555
 556         store = gtk_list_store_new (COL_ACCOUNT_COUNT,
 557                                     G_TYPE_STRING,    /* Image */
 558                                     G_TYPE_STRING,    /* Name */
 559                                     G_TYPE_BOOLEAN,   /* Enabled */
 560                                     TP_TYPE_ACCOUNT);
 561
 562         gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
 563                 account_cmp, chooser, NULL);
 564         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
 565                 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
 566
 567         gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
 568
 569         renderer = gtk_cell_renderer_pixbuf_new ();
 570         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
 571         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
 572                                         "icon-name", COL_ACCOUNT_IMAGE,
 573                                         "sensitive", COL_ACCOUNT_ENABLED,
 574                                         NULL);
 575         g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL);
 576
 577         renderer = gtk_cell_renderer_text_new ();
 578         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
 579         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
 580                                         "text", COL_ACCOUNT_TEXT,
 581                                         "sensitive", COL_ACCOUNT_ENABLED,
 582                                         NULL);
 583
 584         /* Populate accounts */
 585         tp_account_manager_prepare_async (priv->manager, NULL,
 586                                           account_manager_prepared_cb, chooser);
 587
 588         g_object_unref (store);
 589 }
 590
 591 static void
 592 account_chooser_account_validity_changed_cb (TpAccountManager      *manager,
 593                                              TpAccount             *account,
 594                                              gboolean               valid,
 595                                              EmpathyAccountChooser *chooser)
 596 {
 597         if (valid) {
 598                 account_chooser_account_add_foreach (account, chooser);
 599         } else {
 600                 account_chooser_account_remove_foreach (account, chooser);
 601         }
 602 }
 603
 604 static void
 605 account_chooser_account_add_foreach (TpAccount             *account,
 606                                      EmpathyAccountChooser *chooser)
 607 {
 608         GtkListStore *store;
 609         GtkComboBox  *combobox;
 610         GtkTreeIter   iter;
 611         gint          position;
 612
 613         combobox = GTK_COMBO_BOX (chooser);
 614         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 615
 616         position = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL);
 617         gtk_list_store_insert_with_values (store, &iter, position,
 618                                            COL_ACCOUNT_POINTER, account,
 619                                            -1);
 620         account_chooser_update_iter (chooser, &iter);
 621 }
 622
 623 static void
 624 account_chooser_account_removed_cb (TpAccountManager      *manager,
 625                                     TpAccount             *account,
 626                                     EmpathyAccountChooser *chooser)
 627 {
 628         account_chooser_account_remove_foreach (account, chooser);
 629 }
 630
 631 typedef struct {
 632         TpAccount   *account;
 633         GtkTreeIter *iter;
 634         gboolean     found;
 635 } FindAccountData;
 636
 637 static gboolean
 638 account_chooser_find_account_foreach (GtkTreeModel *model,
 639                                       GtkTreePath  *path,
 640                                       GtkTreeIter  *iter,
 641                                       gpointer      user_data)
 642 {
 643         FindAccountData *data = user_data;
 644         TpAccount  *account;
 645
 646         gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
 647
 648         if (account == data->account) {
 649                 data->found = TRUE;
 650                 *(data->iter) = *iter;
 651                 g_object_unref (account);
 652
 653                 return TRUE;
 654         }
 655
 656         g_object_unref (account);
 657
 658         return FALSE;
 659 }
 660
 661 static gboolean
 662 account_chooser_find_account (EmpathyAccountChooser *chooser,
 663                               TpAccount             *account,
 664                               GtkTreeIter           *iter)
 665 {
 666         GtkListStore    *store;
 667         GtkComboBox     *combobox;
 668         FindAccountData  data;
 669
 670         combobox = GTK_COMBO_BOX (chooser);
 671         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 672
 673         data.account = account;
 674         data.iter = iter;
 675         gtk_tree_model_foreach (GTK_TREE_MODEL (store),
 676                                 account_chooser_find_account_foreach,
 677                                 &data);
 678
 679         return data.found;
 680 }
 681
 682 static void
 683 account_chooser_account_remove_foreach (TpAccount             *account,
 684                                         EmpathyAccountChooser *chooser)
 685 {
 686         GtkListStore *store;
 687         GtkComboBox  *combobox;
 688         GtkTreeIter   iter;
 689
 690         combobox = GTK_COMBO_BOX (chooser);
 691         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 692
 693         if (account_chooser_find_account (chooser, account, &iter)) {
 694                 gtk_list_store_remove (store, &iter);
 695         }
 696 }
 697
 698 static void
 699 account_chooser_update_iter (EmpathyAccountChooser *chooser,
 700                              GtkTreeIter           *iter)
 701 {
 702         EmpathyAccountChooserPriv *priv;
 703         GtkListStore              *store;
 704         GtkComboBox               *combobox;
 705         TpAccount                 *account;
 706         const gchar               *icon_name;
 707         gboolean                   is_enabled = TRUE;
 708
 709         priv = GET_PRIV (chooser);
 710
 711         combobox = GTK_COMBO_BOX (chooser);
 712         store = GTK_LIST_STORE (gtk_combo_box_get_model (combobox));
 713
 714         gtk_tree_model_get (GTK_TREE_MODEL (store), iter,
 715                             COL_ACCOUNT_POINTER, &account,
 716                             -1);
 717
 718         icon_name = tp_account_get_icon_name (account);
 719         if (priv->filter) {
 720                 is_enabled = priv->filter (account, priv->filter_data);
 721         }
 722
 723         gtk_list_store_set (store, iter,
 724                             COL_ACCOUNT_IMAGE, icon_name,
 725                             COL_ACCOUNT_TEXT, tp_account_get_display_name (account),
 726                             COL_ACCOUNT_ENABLED, is_enabled,
 727                             -1);
 728
 729         /* set first connected account as active account */
 730         if (priv->account_manually_set == FALSE &&
 731             priv->set_active_item == FALSE && is_enabled) {
 732                 priv->set_active_item = TRUE;
 733                 gtk_combo_box_set_active_iter (combobox, iter);
 734         }
 735
 736         g_object_unref (account);
 737 }
 738
 739 static void
 740 account_chooser_status_changed_cb (TpAccount  *account,
 741                                    guint       old_status,
 742                                    guint       new_status,
 743                                    guint       reason,
 744                                    gchar      *dbus_error_name,
 745                                    GHashTable *details,
 746                                    gpointer    user_data)
 747 {
 748         EmpathyAccountChooser *chooser = user_data;
 749         GtkTreeIter iter;
 750
 751         if (account_chooser_find_account (chooser, account, &iter)) {
 752                 account_chooser_update_iter (chooser, &iter);
 753         }
 754 }
 755
 756 static gboolean
 757 account_chooser_separator_func (GtkTreeModel         *model,
 758                                 GtkTreeIter          *iter,
 759                                 EmpathyAccountChooser *chooser)
 760 {
 761         EmpathyAccountChooserPriv *priv;
 762         gchar                    *text;
 763         gboolean                  is_separator;
 764
 765         priv = GET_PRIV (chooser);
 766
 767         if (!priv->has_all_option) {
 768                 return FALSE;
 769         }
 770
 771         gtk_tree_model_get (model, iter, COL_ACCOUNT_TEXT, &text, -1);
 772         is_separator = text == NULL;
 773         g_free (text);
 774
 775         return is_separator;
 776 }
 777
 778 static gboolean
 779 account_chooser_set_account_foreach (GtkTreeModel   *model,
 780                                      GtkTreePath    *path,
 781                                      GtkTreeIter    *iter,
 782                                      SetAccountData *data)
 783 {
 784         TpAccount *account;
 785         gboolean   equal;
 786
 787         gtk_tree_model_get (model, iter, COL_ACCOUNT_POINTER, &account, -1);
 788
 789         /* Special case so we can make it possible to select the All option */
 790         if ((data->account == NULL) != (account == NULL)) {
 791                 equal = FALSE;
 792         }
 793         else {
 794                 equal = (data->account == account);
 795         }
 796
 797         if (account) {
 798                 g_object_unref (account);
 799         }
 800
 801         if (equal) {
 802                 GtkComboBox *combobox;
 803
 804                 combobox = GTK_COMBO_BOX (data->chooser);
 805                 gtk_combo_box_set_active_iter (combobox, iter);
 806
 807                 data->set = TRUE;
 808         }
 809
 810         return equal;
 811 }
 812
 813 static gboolean
 814 account_chooser_filter_foreach (GtkTreeModel *model,
 815                                 GtkTreePath  *path,
 816                                 GtkTreeIter  *iter,
 817                                 gpointer      chooser)
 818 {
 819         account_chooser_update_iter (chooser, iter);
 820         return FALSE;
 821 }
 822
 823 /**
 824  * empathy_account_chooser_set_filter:
 825  * @chooser: an #EmpathyAccountChooser
 826  * @filter: a filter
 827  * @user_data: data to pass to @filter, or %NULL
 828  *
 829  * Sets a filter on the @chooser so only accounts that are %TRUE in the eyes
 830  * of the filter are visible in the @chooser.
 831  */
 832 void
 833 empathy_account_chooser_set_filter (EmpathyAccountChooser           *chooser,
 834                                     EmpathyAccountChooserFilterFunc  filter,
 835                                     gpointer                         user_data)
 836 {
 837         EmpathyAccountChooserPriv *priv;
 838         GtkTreeModel *model;
 839
 840         g_return_if_fail (EMPATHY_IS_ACCOUNT_CHOOSER (chooser));
 841
 842         priv = GET_PRIV (chooser);
 843
 844         priv->filter = filter;
 845         priv->filter_data = user_data;
 846
 847         /* Refilter existing data */
 848         priv->set_active_item = FALSE;
 849         model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser));
 850         gtk_tree_model_foreach (model, account_chooser_filter_foreach, chooser);
 851 }
 852
 853 /**
 854  * EmpathyAccountChooserFilterFunc:
 855  * @account: a #TpAccount
 856  * @user_data: user data, or %NULL
 857  *
 858  * A function which decides whether the account indicated by @account
 859  * is visible.
 860  *
 861  * Return value: whether the account indicated by @account is visible.
 862  */
 863
 864 /**
 865  * empathy_account_chooser_filter_is_connected:
 866  * @account: a #TpAccount
 867  * @user_data: user data or %NULL
 868  *
 869  * A useful #EmpathyAccountChooserFilterFunc that one could pass into
 870  * empathy_account_chooser_set_filter() and only show connected accounts.
 871  *
 872  * Return value: Whether @account is connected
 873  */
 874 gboolean
 875 empathy_account_chooser_filter_is_connected (TpAccount *account,
 876                                              gpointer   user_data)
 877 {
 878         return (tp_account_get_connection_status (account, NULL)
 879             == TP_CONNECTION_STATUS_CONNECTED);
 880 }
 881
 882 gboolean
 883 empathy_account_chooser_is_ready (EmpathyAccountChooser *self)
 884 {
 885         EmpathyAccountChooserPriv *priv = GET_PRIV (self);
 886
 887         return priv->ready;
 888 }