libempathy-gtk/empathy-irc-network-chooser-dialog.c

   1 /*
   2  * Copyright (C) 2007-2008 Guillaume Desmottes
   3  * Copyright (C) 2010 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Guillaume Desmottes <gdesmott@gnome.org>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27
  28 #include <glib/gi18n-lib.h>
  29 #include <gtk/gtk.h>
  30
  31 #include <libempathy/empathy-utils.h>
  32 #include <libempathy/empathy-irc-network-manager.h>
  33
  34 #include "empathy-irc-network-dialog.h"
  35 #include "empathy-ui-utils.h"
  36 #include "empathy-live-search.h"
  37
  38 #define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT | EMPATHY_DEBUG_IRC
  39 #include <libempathy/empathy-debug.h>
  40
  41 #include "empathy-irc-network-chooser-dialog.h"
  42
  43 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyIrcNetworkChooserDialog)
  44
  45 enum {
  46     PROP_SETTINGS = 1,
  47     PROP_NETWORK
  48 };
  49
  50 typedef struct {
  51     EmpathyAccountSettings *settings;
  52     EmpathyIrcNetwork *network;
  53
  54     EmpathyIrcNetworkManager *network_manager;
  55     gboolean changed;
  56
  57     GtkWidget *treeview;
  58     GtkListStore *store;
  59     GtkTreeModelFilter *filter;
  60     GtkWidget *search;
  61     GtkWidget *select_button;
  62
  63     gulong search_sig;
  64 } EmpathyIrcNetworkChooserDialogPriv;
  65
  66 enum {
  67   COL_NETWORK_OBJ,
  68   COL_NETWORK_NAME,
  69 };
  70
  71 G_DEFINE_TYPE (EmpathyIrcNetworkChooserDialog, empathy_irc_network_chooser_dialog,
  72     GTK_TYPE_DIALOG);
  73
  74 static void
  75 empathy_irc_network_chooser_dialog_set_property (GObject *object,
  76     guint prop_id,
  77     const GValue *value,
  78     GParamSpec *pspec)
  79 {
  80   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (object);
  81
  82   switch (prop_id)
  83     {
  84       case PROP_SETTINGS:
  85         priv->settings = g_value_dup_object (value);
  86         break;
  87       case PROP_NETWORK:
  88         priv->network = g_value_dup_object (value);
  89         break;
  90       default:
  91         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  92         break;
  93     }
  94 }
  95
  96 static void
  97 empathy_irc_network_chooser_dialog_get_property (GObject *object,
  98     guint prop_id,
  99     GValue *value,
 100     GParamSpec *pspec)
 101 {
 102   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (object);
 103
 104   switch (prop_id)
 105     {
 106       case PROP_SETTINGS:
 107         g_value_set_object (value, priv->settings);
 108         break;
 109       case PROP_NETWORK:
 110         g_value_set_object (value, priv->network);
 111         break;
 112       default:
 113         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 114         break;
 115     }
 116 }
 117
 118 /* The iter returned by *it is a priv->store iter (not a filter one) */
 119 static EmpathyIrcNetwork *
 120 dup_selected_network (EmpathyIrcNetworkChooserDialog *self,
 121     GtkTreeIter *it)
 122 {
 123   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 124   EmpathyIrcNetwork *network;
 125   GtkTreeSelection *selection;
 126   GtkTreeIter iter;
 127   GtkTreeModel *model;
 128
 129   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
 130   if (!gtk_tree_selection_get_selected (selection, &model, &iter))
 131     return NULL;
 132
 133   gtk_tree_model_get (model, &iter, COL_NETWORK_OBJ, &network, -1);
 134   g_assert (network != NULL);
 135
 136   if (it != NULL)
 137     {
 138       gtk_tree_model_filter_convert_iter_to_child_iter (priv->filter, it,
 139           &iter);
 140     }
 141
 142   return network;
 143 }
 144
 145 static void
 146 treeview_changed_cb (GtkTreeView *treeview,
 147     EmpathyIrcNetworkChooserDialog *self)
 148 {
 149   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 150   EmpathyIrcNetwork *network;
 151
 152   network = dup_selected_network (self, NULL);
 153   if (network == priv->network)
 154     {
 155       g_object_unref (network);
 156       return;
 157     }
 158
 159   tp_clear_object (&priv->network);
 160   /* Transfer the reference */
 161   priv->network = network;
 162
 163   priv->changed = TRUE;
 164 }
 165
 166 /* Take a filter iterator as argument */
 167 static void
 168 scroll_to_iter (EmpathyIrcNetworkChooserDialog *self,
 169     GtkTreeIter *filter_iter)
 170 {
 171   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 172   GtkTreePath *path;
 173
 174   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->filter), filter_iter);
 175
 176   if (path != NULL)
 177     {
 178       gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (priv->treeview),
 179           path, NULL, FALSE, 0, 0);
 180
 181       gtk_tree_path_free (path);
 182     }
 183 }
 184
 185 /* Take a filter iterator as argument */
 186 static void
 187 select_iter (EmpathyIrcNetworkChooserDialog *self,
 188     GtkTreeIter *filter_iter,
 189     gboolean emulate_changed)
 190 {
 191   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 192   GtkTreeSelection *selection;
 193   GtkTreePath *path;
 194
 195   /* Select the network */
 196   selection = gtk_tree_view_get_selection (
 197       GTK_TREE_VIEW (priv->treeview));
 198
 199   gtk_tree_selection_select_iter (selection, filter_iter);
 200
 201   path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->filter), filter_iter);
 202   if (path != NULL)
 203     {
 204       gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->treeview), path,
 205           NULL, FALSE);
 206
 207       gtk_tree_path_free (path);
 208     }
 209
 210   /* Scroll to the selected network */
 211   scroll_to_iter (self, filter_iter);
 212
 213   if (emulate_changed)
 214     {
 215       /* gtk_tree_selection_select_iter doesn't fire the 'cursor-changed' signal
 216        * so we call the callback manually. */
 217       treeview_changed_cb (GTK_TREE_VIEW (priv->treeview), self);
 218     }
 219 }
 220
 221 static GtkTreeIter
 222 iter_to_filter_iter (EmpathyIrcNetworkChooserDialog *self,
 223     GtkTreeIter *iter)
 224 {
 225   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 226   GtkTreeIter filter_iter;
 227
 228   g_assert (gtk_tree_model_filter_convert_child_iter_to_iter (priv->filter,
 229         &filter_iter, iter));
 230
 231   return filter_iter;
 232 }
 233
 234 static void
 235 fill_store (EmpathyIrcNetworkChooserDialog *self)
 236 {
 237   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 238   GSList *networks, *l;
 239
 240   networks = empathy_irc_network_manager_get_networks (
 241       priv->network_manager);
 242
 243   for (l = networks; l != NULL; l = g_slist_next (l))
 244     {
 245       EmpathyIrcNetwork *network = l->data;
 246       GtkTreeIter iter;
 247
 248       gtk_list_store_insert_with_values (priv->store, &iter, -1,
 249           COL_NETWORK_OBJ, network,
 250           COL_NETWORK_NAME, empathy_irc_network_get_name (network),
 251           -1);
 252
 253       if (network == priv->network)
 254         {
 255           GtkTreeIter filter_iter = iter_to_filter_iter (self, &iter);
 256
 257           select_iter (self, &filter_iter, FALSE);
 258         }
 259
 260       g_object_unref (network);
 261     }
 262
 263   g_slist_free (networks);
 264 }
 265
 266 static void
 267 irc_network_dialog_destroy_cb (GtkWidget *widget,
 268     EmpathyIrcNetworkChooserDialog *self)
 269 {
 270   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 271   EmpathyIrcNetwork *network;
 272   GtkTreeIter iter, filter_iter;
 273
 274   priv->changed = TRUE;
 275
 276   network = dup_selected_network (self, &iter);
 277   if (network == NULL)
 278     return;
 279
 280   /* name could be changed */
 281   gtk_list_store_set (GTK_LIST_STORE (priv->store), &iter,
 282       COL_NETWORK_NAME, empathy_irc_network_get_name (network), -1);
 283
 284   filter_iter = iter_to_filter_iter (self, &iter);
 285   scroll_to_iter (self, &filter_iter);
 286
 287   gtk_widget_grab_focus (priv->treeview);
 288
 289   g_object_unref (network);
 290 }
 291
 292 static void
 293 display_irc_network_dialog (EmpathyIrcNetworkChooserDialog *self,
 294     EmpathyIrcNetwork *network)
 295 {
 296   GtkWidget *dialog;
 297
 298   dialog = empathy_irc_network_dialog_show (network, NULL);
 299
 300   g_signal_connect (dialog, "destroy",
 301       G_CALLBACK (irc_network_dialog_destroy_cb), self);
 302 }
 303
 304 static void
 305 edit_network (EmpathyIrcNetworkChooserDialog *self)
 306 {
 307   EmpathyIrcNetwork *network;
 308
 309   network = dup_selected_network (self, NULL);
 310   if (network == NULL)
 311     return;
 312
 313   display_irc_network_dialog (self, network);
 314
 315   g_object_unref (network);
 316 }
 317
 318 static void
 319 add_network (EmpathyIrcNetworkChooserDialog *self)
 320 {
 321   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 322   EmpathyIrcNetwork *network;
 323   GtkTreeIter iter, filter_iter;
 324
 325   gtk_widget_hide (priv->search);
 326
 327   network = empathy_irc_network_new (_("New Network"));
 328   empathy_irc_network_manager_add (priv->network_manager, network);
 329
 330   gtk_list_store_insert_with_values (priv->store, &iter, -1,
 331       COL_NETWORK_OBJ, network,
 332       COL_NETWORK_NAME, empathy_irc_network_get_name (network),
 333       -1);
 334
 335   filter_iter = iter_to_filter_iter (self, &iter);
 336   select_iter (self, &filter_iter, TRUE);
 337
 338   display_irc_network_dialog (self, network);
 339
 340   g_object_unref (network);
 341 }
 342
 343 static void
 344 remove_network (EmpathyIrcNetworkChooserDialog *self)
 345 {
 346   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 347   EmpathyIrcNetwork *network;
 348   GtkTreeIter iter;
 349
 350   network = dup_selected_network (self, &iter);
 351   if (network == NULL)
 352     return;
 353
 354   /* Hide the search after picking the network to get the right one */
 355   gtk_widget_hide (priv->search);
 356
 357   DEBUG ("Remove network %s", empathy_irc_network_get_name (network));
 358
 359   /* Delete network and select next network */
 360   if (gtk_list_store_remove (priv->store, &iter))
 361     {
 362       GtkTreeIter filter_iter = iter_to_filter_iter (self, &iter);
 363
 364       select_iter (self, &filter_iter, TRUE);
 365     }
 366   else
 367     {
 368       /* this should only happen if the last network was deleted */
 369       GtkTreeIter last, filter_iter;
 370       gint n_elements;
 371
 372       n_elements = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (priv->store),
 373           NULL);
 374
 375       if (n_elements > 0)
 376         {
 377           gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (priv->store), &last,
 378               NULL, (n_elements-1));
 379           filter_iter = iter_to_filter_iter (self, &last);
 380
 381           select_iter (self, &filter_iter, TRUE);
 382         }
 383     }
 384
 385   empathy_irc_network_manager_remove (priv->network_manager, network);
 386   gtk_widget_grab_focus (priv->treeview);
 387
 388   g_object_unref (network);
 389 }
 390
 391 static void
 392 dialog_response_cb (GtkDialog *dialog,
 393     gint response,
 394     EmpathyIrcNetworkChooserDialog *self)
 395 {
 396   if (response == GTK_RESPONSE_OK)
 397     add_network (self);
 398   else if (response == GTK_RESPONSE_APPLY)
 399     edit_network (self);
 400   else if (response == GTK_RESPONSE_REJECT)
 401     remove_network (self);
 402 }
 403
 404 static gboolean
 405 filter_visible_func (GtkTreeModel *model,
 406     GtkTreeIter *iter,
 407     gpointer user_data)
 408 {
 409   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (user_data);
 410   EmpathyIrcNetwork *network;
 411   gboolean visible;
 412
 413   gtk_tree_model_get (model, iter, COL_NETWORK_OBJ, &network, -1);
 414
 415   visible = empathy_live_search_match (EMPATHY_LIVE_SEARCH (priv->search),
 416       empathy_irc_network_get_name (network));
 417
 418   g_object_unref (network);
 419   return visible;
 420 }
 421
 422
 423 static void
 424 search_text_notify_cb (EmpathyLiveSearch *search,
 425     GParamSpec *pspec,
 426     EmpathyIrcNetworkChooserDialog *self)
 427 {
 428   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 429   GtkTreeIter filter_iter;
 430   gboolean sensitive = FALSE;
 431
 432   gtk_tree_model_filter_refilter (priv->filter);
 433
 434   /* Is there at least one network in the view ? */
 435   if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->filter),
 436         &filter_iter))
 437     {
 438       const gchar *text;
 439
 440       text = empathy_live_search_get_text (EMPATHY_LIVE_SEARCH (priv->search));
 441       if (!EMP_STR_EMPTY (text))
 442         {
 443           /* We are doing a search, select the first matching network */
 444           select_iter (self, &filter_iter, TRUE);
 445         }
 446       else
 447         {
 448           /* Search has been cancelled. Scroll to the selected network */
 449           GtkTreeSelection *selection;
 450
 451           selection = gtk_tree_view_get_selection (
 452               GTK_TREE_VIEW (priv->treeview));
 453
 454           if (gtk_tree_selection_get_selected (selection, NULL, &filter_iter))
 455             scroll_to_iter (self, &filter_iter);
 456         }
 457
 458       sensitive = TRUE;
 459     }
 460
 461   gtk_widget_set_sensitive (priv->select_button, sensitive);
 462 }
 463
 464 static void
 465 dialog_destroy_cb (GtkWidget *widget,
 466     EmpathyIrcNetworkChooserDialog *self)
 467 {
 468   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 469
 470   g_signal_handler_disconnect (priv->search, priv->search_sig);
 471 }
 472
 473 static void
 474 empathy_irc_network_chooser_dialog_constructed (GObject *object)
 475 {
 476   EmpathyIrcNetworkChooserDialog *self = (EmpathyIrcNetworkChooserDialog *) object;
 477   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 478   GtkDialog *dialog = GTK_DIALOG (self);
 479   GtkCellRenderer *renderer;
 480   GtkWidget *vbox;
 481   GtkTreeViewColumn *column;
 482   GtkWidget *scroll;
 483
 484   g_assert (priv->settings != NULL);
 485
 486   gtk_window_set_title (GTK_WINDOW (self), _("Choose an IRC network"));
 487
 488   /* Create store and treeview */
 489   priv->store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING);
 490
 491   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store),
 492       COL_NETWORK_NAME,
 493       GTK_SORT_ASCENDING);
 494
 495   priv->treeview = gtk_tree_view_new ();
 496   gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
 497   gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE);
 498
 499   column = gtk_tree_view_column_new ();
 500   gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
 501
 502   renderer = gtk_cell_renderer_text_new ();
 503   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, TRUE);
 504   gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column),
 505       renderer,
 506       "text", COL_NETWORK_NAME,
 507       NULL);
 508
 509   /* add the treeview in a GtkScrolledWindow */
 510   vbox = gtk_dialog_get_content_area (dialog);
 511
 512   scroll = gtk_scrolled_window_new (NULL, NULL);
 513   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
 514       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
 515
 516   gtk_container_add (GTK_CONTAINER (scroll), priv->treeview);
 517   gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 6);
 518
 519   /* Live search */
 520   priv->search = empathy_live_search_new (priv->treeview);
 521
 522   gtk_box_pack_start (GTK_BOX (vbox), priv->search, FALSE, TRUE, 0);
 523
 524   priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (
 525           GTK_TREE_MODEL (priv->store), NULL));
 526   gtk_tree_model_filter_set_visible_func (priv->filter,
 527           filter_visible_func, self, NULL);
 528
 529   gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
 530           GTK_TREE_MODEL (priv->filter));
 531
 532   priv->search_sig = g_signal_connect (priv->search, "notify::text",
 533       G_CALLBACK (search_text_notify_cb), self);
 534
 535   /* Add buttons */
 536   gtk_dialog_add_buttons (dialog,
 537       GTK_STOCK_ADD, GTK_RESPONSE_OK,
 538       GTK_STOCK_EDIT, GTK_RESPONSE_APPLY,
 539       GTK_STOCK_REMOVE, GTK_RESPONSE_REJECT,
 540       NULL);
 541
 542   priv->select_button = gtk_dialog_add_button (dialog, _("Select"),
 543       GTK_RESPONSE_CLOSE);
 544
 545   fill_store (self);
 546
 547   g_signal_connect (priv->treeview, "cursor-changed",
 548       G_CALLBACK (treeview_changed_cb), self);
 549
 550   g_signal_connect (self, "response",
 551       G_CALLBACK (dialog_response_cb), self);
 552   g_signal_connect (self, "destroy",
 553       G_CALLBACK (dialog_destroy_cb), self);
 554
 555   /* Request a side ensuring to display at least some networks */
 556   gtk_widget_set_size_request (GTK_WIDGET (self), -1, 300);
 557
 558   gtk_window_set_modal (GTK_WINDOW (self), TRUE);
 559 }
 560
 561 static void
 562 empathy_irc_network_chooser_dialog_dispose (GObject *object)
 563 {
 564   EmpathyIrcNetworkManager *self = (EmpathyIrcNetworkManager *) object;
 565   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 566
 567   tp_clear_object (&priv->settings);
 568   tp_clear_object (&priv->network);
 569   tp_clear_object (&priv->network_manager);
 570   tp_clear_object (&priv->store);
 571   tp_clear_object (&priv->filter);
 572
 573   if (G_OBJECT_CLASS (empathy_irc_network_chooser_dialog_parent_class)->dispose)
 574     G_OBJECT_CLASS (empathy_irc_network_chooser_dialog_parent_class)->dispose (object);
 575 }
 576
 577 static void
 578 empathy_irc_network_chooser_dialog_class_init (EmpathyIrcNetworkChooserDialogClass *klass)
 579 {
 580   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 581
 582   object_class->get_property = empathy_irc_network_chooser_dialog_get_property;
 583   object_class->set_property = empathy_irc_network_chooser_dialog_set_property;
 584   object_class->constructed = empathy_irc_network_chooser_dialog_constructed;
 585   object_class->dispose = empathy_irc_network_chooser_dialog_dispose;
 586
 587   g_object_class_install_property (object_class, PROP_SETTINGS,
 588     g_param_spec_object ("settings",
 589       "Settings",
 590       "The EmpathyAccountSettings to show and edit",
 591       EMPATHY_TYPE_ACCOUNT_SETTINGS,
 592       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 593
 594   g_object_class_install_property (object_class, PROP_NETWORK,
 595     g_param_spec_object ("network",
 596       "Network",
 597       "The EmpathyIrcNetwork selected in the treeview",
 598       EMPATHY_TYPE_IRC_NETWORK,
 599       G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 600
 601   g_type_class_add_private (object_class,
 602       sizeof (EmpathyIrcNetworkChooserDialogPriv));
 603 }
 604
 605 static void
 606 empathy_irc_network_chooser_dialog_init (EmpathyIrcNetworkChooserDialog *self)
 607 {
 608   EmpathyIrcNetworkChooserDialogPriv *priv;
 609
 610   priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 611       EMPATHY_TYPE_IRC_NETWORK_CHOOSER_DIALOG, EmpathyIrcNetworkChooserDialogPriv);
 612   self->priv = priv;
 613
 614   priv->network_manager = empathy_irc_network_manager_dup_default ();
 615 }
 616
 617 GtkWidget *
 618 empathy_irc_network_chooser_dialog_new (EmpathyAccountSettings *settings,
 619     EmpathyIrcNetwork *network,
 620     GtkWindow *parent)
 621 {
 622   return g_object_new (EMPATHY_TYPE_IRC_NETWORK_CHOOSER_DIALOG,
 623       "settings", settings,
 624       "network", network,
 625       "transient-for", parent,
 626       NULL);
 627 }
 628
 629 EmpathyIrcNetwork *
 630 empathy_irc_network_chooser_dialog_get_network (
 631     EmpathyIrcNetworkChooserDialog *self)
 632 {
 633   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 634
 635   return priv->network;
 636 }
 637
 638 gboolean
 639 empathy_irc_network_chooser_dialog_get_changed (
 640     EmpathyIrcNetworkChooserDialog *self)
 641 {
 642   EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self);
 643
 644   return priv->changed;
 645 }