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