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