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