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