a few more appindicator fixes and reindent trg-main-window.c

4 files changed, 1323 insertions, 907 deletions

diff --git a/Makefile.am b/Makefile.am
index 4c92f22..137915e 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,3 +1,22 @@
+#
+# transmission-remote-gtk - A GTK RPC client to Transmission
+# Copyright (C) 2011  Alan Fitton
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
 ACLOCAL_AMFLAGS = -I m4
 AUTOMAKE_OPTIONS = foreign
 SUBDIRS = src po
diff --git a/configure.ac b/configure.ac
index 3a2d7e5..7a30dec 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,3 +1,22 @@
+dnl
+dnl transmission-remote-gtk - A GTK RPC client to Transmission
+dnl Copyright (C) 2011  Alan Fitton
+
+dnl This program is free software; you can redistribute it and/or modify
+dnl it under the terms of the GNU General Public License as published by
+dnl the Free Software Foundation; either version 2 of the License, or
+dnl (at your option) any later version.
+
+dnl This program is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+dnl GNU General Public License for more details.
+
+dnl You should have received a copy of the GNU General Public License along
+dnl with this program; if not, write to the Free Software Foundation, Inc.,
+dnl 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+dnl
+
 AC_PREREQ(2.63)
 
 AC_INIT(transmission-remote-gtk, 0.8, alan@eth0.org.uk)
diff --git a/src/Makefile.am b/src/Makefile.am
index 7e16160..7345485 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,3 +1,22 @@
+#
+# transmission-remote-gtk - A GTK RPC client to Transmission
+# Copyright (C) 2011  Alan Fitton
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
 NULL =
 
 public_icons_themes = \
diff --git a/src/trg-main-window.c b/src/trg-main-window.c
index 6c72c3d..95cd703 100644
--- a/src/trg-main-window.c
+++ b/src/trg-main-window.c
@@ -31,7 +31,7 @@
 #include <gtk/gtk.h>
 #include <json-glib/json-glib.h>
 #include <gdk/gdkkeysyms.h>
-#if GTK_CHECK_VERSION( 3,0, 0 )
+#if GTK_CHECK_VERSION( 3, 0, 0 )
 #include <gdk/gdkkeysyms-compat.h>
 #endif
 #include <curl/curl.h>
@@ -81,23 +81,31 @@
 
 /* The rather large main window class, which glues everything together. */
 
-static void update_selected_torrent_notebook(TrgMainWindow * win, gint mode,
-        gint64 id);
+static void update_selected_torrent_notebook(TrgMainWindow * win,
+					     gint mode, gint64 id);
 #ifdef HAVE_LIBNOTIFY
-static void torrent_event_notification(TrgTorrentModel * model, gchar * icon,
-        gchar * desc, gint tmout, gchar * prefKey, GtkTreeIter * iter,
-        gpointer data);
+static void torrent_event_notification(TrgTorrentModel * model,
+				       gchar * icon, gchar * desc,
+				       gint tmout, gchar * prefKey,
+				       GtkTreeIter * iter, gpointer data);
 #endif
-static void connchange_whatever_statusicon(TrgMainWindow *win, gboolean connected);
-static void update_whatever_statusicon(TrgMainWindow *win, const gchar *speedLabel, trg_torrent_model_update_stats *stats);
-static void on_torrent_completed(TrgTorrentModel * model, GtkTreeIter * iter,
-        gpointer data);
+static void connchange_whatever_statusicon(TrgMainWindow * win,
+					   gboolean connected);
+static void update_whatever_statusicon(TrgMainWindow * win,
+				       const gchar * speedLabel,
+				       trg_torrent_model_update_stats *
+				       stats);
+static void on_torrent_completed(TrgTorrentModel * model,
+				 GtkTreeIter * iter, gpointer data);
 static void on_torrent_added(TrgTorrentModel * model, GtkTreeIter * iter,
-        gpointer data);
-static gboolean delete_event(GtkWidget * w, GdkEvent * event, gpointer data);
+			     gpointer data);
+static gboolean delete_event(GtkWidget * w, GdkEvent * event,
+			     gpointer data);
 static void destroy_window(GtkWidget * w, gpointer data);
 static void torrent_tv_onRowActivated(GtkTreeView * treeview,
-        GtkTreePath * path, GtkTreeViewColumn * col, gpointer userdata);
+				      GtkTreePath * path,
+				      GtkTreeViewColumn * col,
+				      gpointer userdata);
 static void add_url_cb(GtkWidget * w, gpointer data);
 static void add_cb(GtkWidget * w, gpointer data);
 static void disconnect_cb(GtkWidget * w, gpointer data);
@@ -115,8 +123,10 @@ static void move_cb(GtkWidget * w, gpointer data);
 static void delete_cb(GtkWidget * w, gpointer data);
 static void open_props_cb(GtkWidget * w, gpointer data);
 static gint confirm_action_dialog(GtkWindow * win,
-        GtkTreeSelection * selection, gchar * question_single,
-        gchar * question_multi, gchar * action_stock);
+				  GtkTreeSelection * selection,
+				  gchar * question_single,
+				  gchar * question_multi,
+				  gchar * action_stock);
 static void view_stats_toggled_cb(GtkWidget * w, gpointer data);
 static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data);
 static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data);
@@ -130,55 +140,67 @@ static gboolean on_torrent_get_interactive(gpointer data);
 static gboolean trg_update_torrents_timerfunc(gpointer data);
 static void open_about_cb(GtkWidget * w, GtkWindow * parent);
 static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model,
-        GtkTreeIter * iter, gpointer data);
-static TrgTorrentTreeView
-* trg_main_window_torrent_tree_view_new(TrgMainWindow * win,
-        GtkTreeModel * model);
+						   GtkTreeIter * iter,
+						   gpointer data);
+static TrgTorrentTreeView *
+trg_main_window_torrent_tree_view_new(TrgMainWindow * win,
+				      GtkTreeModel * model);
 static gboolean trg_dialog_error_handler(TrgMainWindow * win,
-        trg_response *response);
+					 trg_response * response);
 static gboolean torrent_selection_changed(GtkTreeSelection * selection,
-        gpointer data);
+					  gpointer data);
 static void trg_main_window_torrent_scrub(TrgMainWindow * win);
 static void entry_filter_changed_cb(GtkWidget * w, gpointer data);
 static void torrent_state_selection_changed(TrgStateSelector * selector,
-        guint flag, gpointer data);
+					    guint flag, gpointer data);
 static void trg_main_window_conn_changed(TrgMainWindow * win,
-        gboolean connected);
-static void trg_main_window_get_property(GObject * object, guint property_id,
-        GValue * value, GParamSpec * pspec);
-static void trg_main_window_set_property(GObject * object, guint property_id,
-        const GValue * value, GParamSpec * pspec);
+					 gboolean connected);
+static void trg_main_window_get_property(GObject * object,
+					 guint property_id, GValue * value,
+					 GParamSpec * pspec);
+static void trg_main_window_set_property(GObject * object,
+					 guint property_id,
+					 const GValue * value,
+					 GParamSpec * pspec);
 static void quit_cb(GtkWidget * w, gpointer data);
 static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win);
 #ifndef HAVE_LIBAPPINDICATOR
 static void status_icon_activated(GtkStatusIcon * icon, gpointer data);
 static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon,
-        gpointer userdata);
+					      gpointer userdata);
 static gboolean status_icon_button_press_event(GtkStatusIcon * icon,
-        GdkEventButton * event, gpointer data);
+					       GdkEventButton * event,
+					       gpointer data);
 #endif
-static void clear_filter_entry_cb(GtkEntry *entry,
-        GtkEntryIconPosition icon_pos,
-        GdkEvent            *event,
-        gpointer             user_data);
-static gboolean torrent_tv_key_press_event(GtkWidget * w, GdkEventKey * key,
-        gpointer data);
-static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text,
-        char *stock_id, gboolean sensitive, GCallback cb, gpointer cbdata);
+static void clear_filter_entry_cb(GtkEntry * entry,
+				  GtkEntryIconPosition icon_pos,
+				  GdkEvent * event, gpointer user_data);
+static gboolean torrent_tv_key_press_event(GtkWidget * w,
+					   GdkEventKey * key,
+					   gpointer data);
+static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell,
+					const gchar * text, char *stock_id,
+					gboolean sensitive, GCallback cb,
+					gpointer cbdata);
 static void set_limit_cb(GtkWidget * w, gpointer data);
 static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu,
-        gint64 currentLimit, gfloat limit);
+				 gint64 currentLimit, gfloat limit);
 static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
-        gchar * enabledKey, gchar * speedKey, JsonArray * ids);
+				 gchar * enabledKey, gchar * speedKey,
+				 JsonArray * ids);
 static void trg_torrent_tv_view_menu(GtkWidget * treeview,
-        GdkEventButton * event, gpointer data);
-static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg);
+				     GdkEventButton * event,
+				     gpointer data);
+static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
+					  const gchar * msg);
 static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview,
-        GdkEventButton * event, gpointer userdata);
+					     GdkEventButton * event,
+					     gpointer userdata);
 static gboolean torrent_tv_popup_menu_cb(GtkWidget * treeview,
-        gpointer userdata);
+					 gpointer userdata);
 static gboolean window_state_event(GtkWidget * widget,
-        GdkEventWindowState * event, gpointer trayIcon);
+				   GdkEventWindowState * event,
+				   gpointer trayIcon);
 
 G_DEFINE_TYPE(TrgMainWindow, trg_main_window, GTK_TYPE_WINDOW)
 #define TRG_MAIN_WINDOW_GET_PRIVATE(o) \
@@ -193,7 +215,8 @@ struct _TrgMainWindowPrivate {
     TrgStatusBar *statusBar;
 #ifdef HAVE_LIBAPPINDICATOR
     AppIndicator *appIndicator;
-    GtkWidget *appIndicatorStatusItem;
+    GtkWidget *appIndicatorStatusItem, *appIndicatorDownloadingItem,
+	*appIndicatorSeedingItem, *appIndicatorSepItem;
 #else
     GtkStatusIcon *statusIcon;
 #endif
@@ -242,74 +265,83 @@ static void reset_connect_args(TrgMainWindow * win)
 {
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     if (priv->args) {
-        g_strfreev(priv->args);
-        priv->args = NULL;
+	g_strfreev(priv->args);
+	priv->args = NULL;
     }
 }
 
-static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED) {
+static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED)
+{
 }
 
-GtkTreeModel *trg_main_window_get_torrent_model(TrgMainWindow * win) {
+GtkTreeModel *trg_main_window_get_torrent_model(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     return GTK_TREE_MODEL(priv->torrentModel);
 }
 
-gint trg_mw_get_selected_torrent_id(TrgMainWindow * win) {
+gint trg_mw_get_selected_torrent_id(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     return priv->selectedTorrentId;
 }
 
-static void update_selected_torrent_notebook(TrgMainWindow * win, gint mode,
-        gint64 id) {
+static void update_selected_torrent_notebook(TrgMainWindow * win,
+					     gint mode, gint64 id)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgClient *client = priv->client;
     JsonObject *t;
     GtkTreeIter iter;
 
-    if (id >= 0 && get_torrent_data(trg_client_get_torrent_table(client), id,
-            &t, &iter)) {
-        trg_toolbar_torrent_actions_sensitive(priv->toolBar, TRUE);
-        trg_menu_bar_torrent_actions_sensitive(priv->menuBar, TRUE);
-        trg_general_panel_update(priv->genDetails, t, &iter);
-        trg_trackers_model_update(priv->trackersModel,
-                trg_client_get_serial(client), t, mode);
-        trg_files_model_update(priv->filesModel, trg_client_get_serial(client),
-                t, mode);
-        trg_peers_model_update(priv->peersModel, TRG_TREE_VIEW(priv->peersTreeView), trg_client_get_serial(client),
-                t, mode);
+    if (id >= 0
+	&& get_torrent_data(trg_client_get_torrent_table(client), id, &t,
+			    &iter)) {
+	trg_toolbar_torrent_actions_sensitive(priv->toolBar, TRUE);
+	trg_menu_bar_torrent_actions_sensitive(priv->menuBar, TRUE);
+	trg_general_panel_update(priv->genDetails, t, &iter);
+	trg_trackers_model_update(priv->trackersModel,
+				  trg_client_get_serial(client), t, mode);
+	trg_files_model_update(priv->filesModel,
+			       trg_client_get_serial(client), t, mode);
+	trg_peers_model_update(priv->peersModel,
+			       TRG_TREE_VIEW(priv->peersTreeView),
+			       trg_client_get_serial(client), t, mode);
     } else if (id < 0) {
-        trg_main_window_torrent_scrub(win);
+	trg_main_window_torrent_scrub(win);
     }
 
     priv->selectedTorrentId = id;
 }
 
 #ifdef HAVE_LIBNOTIFY
-static void torrent_event_notification(TrgTorrentModel * model, gchar * icon,
-        gchar * desc, gint tmout, gchar * prefKey, GtkTreeIter * iter,
-        gpointer data) {
+static void torrent_event_notification(TrgTorrentModel * model,
+				       gchar * icon, gchar * desc,
+				       gint tmout, gchar * prefKey,
+				       GtkTreeIter * iter, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     gchar *name;
     NotifyNotification *notify;
 
     if (!trg_prefs_get_bool(prefs, prefKey, TRG_PREFS_NOFLAGS))
-        return;
+	return;
 
-    gtk_tree_model_get(GTK_TREE_MODEL(model), iter, TORRENT_COLUMN_NAME, &name,
-            -1);
+    gtk_tree_model_get(GTK_TREE_MODEL(model), iter, TORRENT_COLUMN_NAME,
+		       &name, -1);
 
     notify = notify_notification_new(name, desc, icon
 #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
-            , NULL
+				     , NULL
 #endif
-            );
+	);
 
 #ifndef HAVE_LIBAPPINDICATOR
 #if !defined(NOTIFY_VERSION_MINOR) || (NOTIFY_VERSION_MAJOR == 0 && NOTIFY_VERSION_MINOR < 7)
-if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon))
-    notify_notification_attach_to_status_icon(notify, priv->statusIcon);
+    if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon))
+	notify_notification_attach_to_status_icon(notify,
+						  priv->statusIcon);
 #endif
 #endif
 
@@ -322,46 +354,55 @@ if (priv->statusIcon && gtk_status_icon_is_embedded(priv->statusIcon))
 }
 #endif
 
-static void on_torrent_completed(TrgTorrentModel * model, GtkTreeIter * iter,
-        gpointer data) {
+static void on_torrent_completed(TrgTorrentModel * model,
+				 GtkTreeIter * iter, gpointer data)
+{
 #ifdef HAVE_LIBNOTIFY
     torrent_event_notification(model, GTK_STOCK_APPLY,
-            _("This torrent has completed."),
-            TORRENT_COMPLETE_NOTIFY_TMOUT, TRG_PREFS_KEY_COMPLETE_NOTIFY, iter,
-            data);
+			       _("This torrent has completed."),
+			       TORRENT_COMPLETE_NOTIFY_TMOUT,
+			       TRG_PREFS_KEY_COMPLETE_NOTIFY, iter, data);
 #endif
 }
 
-static void on_update_filters(TrgTorrentModel * model, gpointer data) {
+static void on_update_filters(TrgTorrentModel * model, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     trg_state_selector_update(priv->stateSelector);
 }
 
 static void on_torrent_added(TrgTorrentModel * model, GtkTreeIter * iter,
-        gpointer data) {
+			     gpointer data)
+{
 #ifdef HAVE_LIBNOTIFY
     torrent_event_notification(model, GTK_STOCK_ADD,
-            _("This torrent has been added."), TORRENT_ADD_NOTIFY_TMOUT,
-            TRG_PREFS_KEY_ADD_NOTIFY, iter, data);
+			       _("This torrent has been added."),
+			       TORRENT_ADD_NOTIFY_TMOUT,
+			       TRG_PREFS_KEY_ADD_NOTIFY, iter, data);
 #endif
 }
 
-static gboolean delete_event(GtkWidget * w, GdkEvent * event G_GNUC_UNUSED, gpointer data G_GNUC_UNUSED) {
+static gboolean delete_event(GtkWidget * w, GdkEvent * event G_GNUC_UNUSED,
+			     gpointer data G_GNUC_UNUSED)
+{
     return FALSE;
 }
 
-static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED) {
+static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(w);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
 
     trg_prefs_set_int(prefs, TRG_PREFS_KEY_WINDOW_HEIGHT, priv->height,
-            TRG_PREFS_GLOBAL);
+		      TRG_PREFS_GLOBAL);
     trg_prefs_set_int(prefs, TRG_PREFS_KEY_WINDOW_WIDTH, priv->width,
-            TRG_PREFS_GLOBAL);
-    trg_prefs_set_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, gtk_paned_get_position(GTK_PANED(priv->vpaned)),
-            TRG_PREFS_GLOBAL);
-    trg_prefs_set_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, gtk_paned_get_position(GTK_PANED(priv->hpaned)),
-            TRG_PREFS_GLOBAL);
+		      TRG_PREFS_GLOBAL);
+    trg_prefs_set_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS,
+		      gtk_paned_get_position(GTK_PANED(priv->vpaned)),
+		      TRG_PREFS_GLOBAL);
+    trg_prefs_set_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS,
+		      gtk_paned_get_position(GTK_PANED(priv->hpaned)),
+		      TRG_PREFS_GLOBAL);
 
     trg_tree_view_persist(TRG_TREE_VIEW(priv->peersTreeView), FALSE);
     trg_tree_view_persist(TRG_TREE_VIEW(priv->filesTreeView), FALSE);
@@ -372,50 +413,62 @@ static void destroy_window(GtkWidget * w, gpointer data G_GNUC_UNUSED) {
     gtk_main_quit();
 }
 
-static void open_props_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void open_props_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
-    TrgTorrentPropsDialog *dialog = trg_torrent_props_dialog_new(
-            GTK_WINDOW(data), priv->torrentTreeView, priv->client);
+    TrgTorrentPropsDialog *dialog =
+	trg_torrent_props_dialog_new(GTK_WINDOW(data),
+				     priv->torrentTreeView, priv->client);
 
     gtk_widget_show_all(GTK_WIDGET(dialog));
 }
 
 static void torrent_tv_onRowActivated(GtkTreeView * treeview,
-        GtkTreePath * path G_GNUC_UNUSED, GtkTreeViewColumn * col G_GNUC_UNUSED, gpointer userdata) {
+				      GtkTreePath * path G_GNUC_UNUSED,
+				      GtkTreeViewColumn *
+				      col G_GNUC_UNUSED, gpointer userdata)
+{
     open_props_cb(GTK_WIDGET(treeview), userdata);
 }
 
-static void add_url_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void add_url_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindow *win = TRG_MAIN_WINDOW(data);
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     TrgTorrentAddUrlDialog *dlg = trg_torrent_add_url_dialog_new(win,
-            priv->client);
+								 priv->
+								 client);
     gtk_widget_show_all(GTK_WIDGET(dlg));
 }
 
-static void add_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void add_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     trg_torrent_add_dialog(TRG_MAIN_WINDOW(data), priv->client);
 }
 
-static void pause_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void pause_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_pause(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_pause(build_json_id_array
+				 (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void pause_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client, torrent_pause(NULL),
-            on_generic_interactive_action, data);
+		   on_generic_interactive_action, data);
 }
 
-gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) {
+gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgClient *client = priv->client;
     TrgPrefs *prefs = trg_client_get_prefs(client);
@@ -423,56 +476,62 @@ gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) {
     int i;
 
     for (i = 0; uris[i]; i++)
-        filesList = g_slist_append(filesList, uris[i]);
+	filesList = g_slist_append(filesList, uris[i]);
 
     if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_ADD_OPTIONS_DIALOG,
-            TRG_PREFS_GLOBAL)) {
-        TrgTorrentAddDialog *dialog = trg_torrent_add_dialog_new(win, client,
-                filesList);
+			   TRG_PREFS_GLOBAL)) {
+	TrgTorrentAddDialog *dialog =
+	    trg_torrent_add_dialog_new(win, client,
+				       filesList);
 
-        gtk_widget_show_all(GTK_WIDGET(dialog));
+	gtk_widget_show_all(GTK_WIDGET(dialog));
     } else {
-        struct add_torrent_threadfunc_args *args =
-                g_new0(struct add_torrent_threadfunc_args, 1);
-        args->list = filesList;
-        args->cb_data = win;
-        args->client = client;
-        args->extraArgs = FALSE;
-        args->flags = trg_prefs_get_add_flags(prefs);
-
-        launch_add_thread(args);
+	struct add_torrent_threadfunc_args *args =
+	    g_new0(struct add_torrent_threadfunc_args, 1);
+	args->list = filesList;
+	args->cb_data = win;
+	args->client = client;
+	args->extraArgs = FALSE;
+	args->flags = trg_prefs_get_add_flags(prefs);
+
+	launch_add_thread(args);
     }
 
-    g_free(uris);  // launch_add_thread() or trg_torrent_add_dialog() will free the filenames and fileList;
+    g_free(uris);		// launch_add_thread() or trg_torrent_add_dialog() will free the filenames and fileList;
 
     priv->args = NULL;
 
     return TRUE;
 }
 
-static void resume_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void resume_all_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client, torrent_start(NULL),
-            on_generic_interactive_action, data);
+		   on_generic_interactive_action, data);
 }
 
-static void resume_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void resume_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_start(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_start(build_json_id_array
+				 (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     trg_main_window_conn_changed(TRG_MAIN_WINDOW(data), FALSE);
     trg_status_bar_reset(priv->statusBar);
 }
 
-void connect_cb(GtkWidget * w, gpointer data) {
+void connect_cb(GtkWidget * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     JsonObject *currentProfile = trg_prefs_get_profile(prefs);
@@ -481,93 +540,107 @@ void connect_cb(GtkWidget * w, gpointer data) {
     int populate_result;
 
     if (w)
-        profile = (JsonObject*)g_object_get_data(G_OBJECT(w), "profile");
+	profile = (JsonObject *) g_object_get_data(G_OBJECT(w), "profile");
 
     if (trg_client_is_connected(priv->client))
-    	disconnect_cb(NULL, data);
+	disconnect_cb(NULL, data);
 
     if (profile && currentProfile != profile)
-        trg_prefs_set_profile(prefs, profile);
+	trg_prefs_set_profile(prefs, profile);
     else
-        trg_prefs_profile_change_emit_signal(prefs);
+	trg_prefs_profile_change_emit_signal(prefs);
 
     populate_result = trg_client_populate_with_settings(priv->client);
 
     if (populate_result < 0) {
-        gchar *msg;
-
-        switch (populate_result) {
-        case TRG_NO_HOSTNAME_SET:
-            msg = _("No hostname set");
-            break;
-        default:
-            msg = _("Unknown error getting settings");
-            break;
-        }
-
-        dialog = gtk_message_dialog_new(GTK_WINDOW(data),
-                GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
-                GTK_BUTTONS_OK, "%s", msg);
-        gtk_dialog_run(GTK_DIALOG(dialog));
-        gtk_widget_destroy(dialog);
-        reset_connect_args(TRG_MAIN_WINDOW(data));
-        return;
+	gchar *msg;
+
+	switch (populate_result) {
+	case TRG_NO_HOSTNAME_SET:
+	    msg = _("No hostname set");
+	    break;
+	default:
+	    msg = _("Unknown error getting settings");
+	    break;
+	}
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(data),
+					GTK_DIALOG_DESTROY_WITH_PARENT,
+					GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+					"%s", msg);
+	gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	reset_connect_args(TRG_MAIN_WINDOW(data));
+	return;
     }
 
-    trg_status_bar_push_connection_msg(priv->statusBar, _("Connecting..."));
+    trg_status_bar_push_connection_msg(priv->statusBar,
+				       _("Connecting..."));
     trg_client_inc_connid(priv->client);
     dispatch_async(priv->client, session_get(), on_session_get, data);
 }
 
-static void open_local_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void open_local_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    GtkWidget *dlg = trg_preferences_dialog_get_instance(TRG_MAIN_WINDOW(data),
-            priv->client);
+    GtkWidget *dlg =
+	trg_preferences_dialog_get_instance(TRG_MAIN_WINDOW(data),
+					    priv->client);
     gtk_widget_show_all(dlg);
 }
 
-static void open_remote_prefs_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void open_remote_prefs_cb(GtkWidget * w G_GNUC_UNUSED,
+				 gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    TrgRemotePrefsDialog *dlg = trg_remote_prefs_dialog_get_instance(
-            TRG_MAIN_WINDOW(data), priv->client);
+    TrgRemotePrefsDialog *dlg =
+	trg_remote_prefs_dialog_get_instance(TRG_MAIN_WINDOW(data),
+					     priv->client);
 
     gtk_widget_show_all(GTK_WIDGET(dlg));
 }
 
-static void main_window_toggle_filter_dirs(GtkCheckMenuItem * w, gpointer win) {
+static void main_window_toggle_filter_dirs(GtkCheckMenuItem * w,
+					   gpointer win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     trg_state_selector_set_show_dirs(priv->stateSelector,
-            gtk_check_menu_item_get_active(w));
+				     gtk_check_menu_item_get_active(w));
 }
 
 static void main_window_toggle_filter_trackers(GtkCheckMenuItem * w,
-        gpointer win) {
+					       gpointer win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     trg_state_selector_set_show_trackers(priv->stateSelector,
-            gtk_check_menu_item_get_active(w));
+					 gtk_check_menu_item_get_active
+					 (w));
 }
 
-static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win) {
+static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
 
     GObject *b_connect, *b_disconnect, *b_add, *b_resume, *b_pause;
-    GObject *b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs;
+    GObject *b_remove, *b_delete, *b_props, *b_local_prefs,
+	*b_remote_prefs;
 
     TrgToolbar *toolBar = trg_toolbar_new(win, prefs);
 
-    g_object_get(toolBar, "connect-button", &b_connect, "disconnect-button",
-            &b_disconnect, "add-button", &b_add, "resume-button", &b_resume,
-            "pause-button", &b_pause, "delete-button", &b_delete,
-            "remove-button", &b_remove, "props-button", &b_props,
-            "remote-prefs-button", &b_remote_prefs, "local-prefs-button",
-            &b_local_prefs, NULL);
+    g_object_get(toolBar, "connect-button", &b_connect,
+		 "disconnect-button", &b_disconnect, "add-button", &b_add,
+		 "resume-button", &b_resume, "pause-button", &b_pause,
+		 "delete-button", &b_delete, "remove-button", &b_remove,
+		 "props-button", &b_props, "remote-prefs-button",
+		 &b_remote_prefs, "local-prefs-button", &b_local_prefs,
+		 NULL);
 
     g_signal_connect(b_connect, "clicked", G_CALLBACK(connect_cb), win);
     g_signal_connect(b_disconnect, "clicked",
-            G_CALLBACK(disconnect_cb), win);
+		     G_CALLBACK(disconnect_cb), win);
     g_signal_connect(b_add, "clicked", G_CALLBACK(add_cb), win);
     g_signal_connect(b_resume, "clicked", G_CALLBACK(resume_cb), win);
     g_signal_connect(b_pause, "clicked", G_CALLBACK(pause_cb), win);
@@ -575,75 +648,89 @@ static TrgToolbar *trg_main_window_toolbar_new(TrgMainWindow * win) {
     g_signal_connect(b_remove, "clicked", G_CALLBACK(remove_cb), win);
     g_signal_connect(b_props, "clicked", G_CALLBACK(open_props_cb), win);
     g_signal_connect(b_local_prefs, "clicked",
-            G_CALLBACK(open_local_prefs_cb), win);
+		     G_CALLBACK(open_local_prefs_cb), win);
     g_signal_connect(b_remote_prefs, "clicked",
-            G_CALLBACK(open_remote_prefs_cb), win);
+		     G_CALLBACK(open_remote_prefs_cb), win);
 
     return toolBar;
 }
 
-static void reannounce_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void reannounce_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_reannounce(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_reannounce(build_json_id_array
+				      (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void verify_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void verify_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_verify(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_verify(build_json_id_array
+				  (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void start_now_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_start_now(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_start_now(build_json_id_array
+				     (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void up_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_queue_move_up(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_queue_move_up(build_json_id_array
+					 (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void top_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     dispatch_async(priv->client,
-            torrent_queue_move_top(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+		   torrent_queue_move_top(build_json_id_array
+					  (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void bottom_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void bottom_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    dispatch_async(
-            priv->client,
-            torrent_queue_move_bottom(
-                    build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+    dispatch_async(priv->client,
+		   torrent_queue_move_bottom(build_json_id_array
+					     (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
-static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void down_queue_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    dispatch_async(
-            priv->client,
-            torrent_queue_move_down(build_json_id_array(priv->torrentTreeView)),
-            on_generic_interactive_action, data);
+    dispatch_async(priv->client,
+		   torrent_queue_move_down(build_json_id_array
+					   (priv->torrentTreeView)),
+		   on_generic_interactive_action, data);
 }
 
 static gint confirm_action_dialog(GtkWindow * win,
-        GtkTreeSelection * selection, gchar * question_single,
-        gchar * question_multi, gchar * action_stock) {
+				  GtkTreeSelection * selection,
+				  gchar * question_single,
+				  gchar * question_multi,
+				  gchar * action_stock)
+{
     TrgMainWindowPrivate *priv;
     gint selectCount;
     gint response;
@@ -654,179 +741,215 @@ static gint confirm_action_dialog(GtkWindow * win,
     selectCount = gtk_tree_selection_count_selected_rows(selection);
 
     if (selectCount == 1) {
-        GList *list;
-        GList *firstNode;
-        GtkTreeIter firstIter;
-        gchar *name = NULL;
-
-        list = gtk_tree_selection_get_selected_rows(selection, NULL);
-        firstNode = g_list_first(list);
-
-        gtk_tree_model_get_iter(GTK_TREE_MODEL
-        (priv->filteredTorrentModel), &firstIter, firstNode->data);
-        gtk_tree_model_get(GTK_TREE_MODEL
-        (priv->filteredTorrentModel), &firstIter, TORRENT_COLUMN_NAME,
-                &name, -1);
-        g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
-        g_list_free(list);
-
-        dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win),
-                GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
-                GTK_BUTTONS_NONE, question_single, name);
-        g_free(name);
+	GList *list;
+	GList *firstNode;
+	GtkTreeIter firstIter;
+	gchar *name = NULL;
+
+	list = gtk_tree_selection_get_selected_rows(selection, NULL);
+	firstNode = g_list_first(list);
+
+	gtk_tree_model_get_iter(GTK_TREE_MODEL
+				(priv->filteredTorrentModel), &firstIter,
+				firstNode->data);
+	gtk_tree_model_get(GTK_TREE_MODEL(priv->filteredTorrentModel),
+			   &firstIter, TORRENT_COLUMN_NAME, &name, -1);
+	g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
+	g_list_free(list);
+
+	dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win),
+						    GTK_DIALOG_DESTROY_WITH_PARENT,
+						    GTK_MESSAGE_QUESTION,
+						    GTK_BUTTONS_NONE,
+						    question_single, name);
+	g_free(name);
     } else if (selectCount > 1) {
-        dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win),
-                GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
-                GTK_BUTTONS_NONE, question_multi, selectCount);
+	dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(win),
+						    GTK_DIALOG_DESTROY_WITH_PARENT,
+						    GTK_MESSAGE_QUESTION,
+						    GTK_BUTTONS_NONE,
+						    question_multi,
+						    selectCount);
 
     } else {
-        return 0;
+	return 0;
     }
 
     gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_CANCEL,
-            GTK_RESPONSE_CANCEL, action_stock, GTK_RESPONSE_ACCEPT, NULL);
-    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
+			   GTK_RESPONSE_CANCEL, action_stock,
+			   GTK_RESPONSE_ACCEPT, NULL);
+    gtk_dialog_set_default_response(GTK_DIALOG(dialog),
+				    GTK_RESPONSE_CANCEL);
     gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog),
-            GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1);
+					    GTK_RESPONSE_ACCEPT,
+					    GTK_RESPONSE_CANCEL, -1);
 
     response = gtk_dialog_run(GTK_DIALOG(dialog));
     gtk_widget_destroy(dialog);
     return response;
 }
 
-static void move_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void move_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
-    TrgTorrentMoveDialog *dlg = trg_torrent_move_dialog_new(
-            TRG_MAIN_WINDOW(data), priv->client, priv->torrentTreeView);
+    TrgTorrentMoveDialog *dlg =
+	trg_torrent_move_dialog_new(TRG_MAIN_WINDOW(data), priv->client,
+				    priv->torrentTreeView);
     gtk_widget_show_all(GTK_WIDGET(dlg));
 }
 
-static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv;
     GtkTreeSelection *selection;
     JsonArray *ids;
 
     priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    selection = gtk_tree_view_get_selection(
-            GTK_TREE_VIEW(priv->torrentTreeView));
+    selection =
+	gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView));
     ids = build_json_id_array(priv->torrentTreeView);
     if (confirm_action_dialog(GTK_WINDOW(data), selection,
-            _("<big><b>Remove torrent \"%s\"?</b></big>"),
-            _("<big><b>Remove %d torrents?</b></big>"), GTK_STOCK_REMOVE)
-            == GTK_RESPONSE_ACCEPT)
-        dispatch_async(priv->client, torrent_remove(ids, FALSE),
-                on_generic_interactive_action, data);
+			      _
+			      ("<big><b>Remove torrent \"%s\"?</b></big>"),
+			      _("<big><b>Remove %d torrents?</b></big>"),
+			      GTK_STOCK_REMOVE)
+	== GTK_RESPONSE_ACCEPT)
+	dispatch_async(priv->client, torrent_remove(ids, FALSE),
+		       on_generic_interactive_action, data);
     else
-        json_array_unref(ids);
+	json_array_unref(ids);
 }
 
-static void delete_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void delete_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv;
     GtkTreeSelection *selection;
     JsonArray *ids;
 
     priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    selection = gtk_tree_view_get_selection(
-            GTK_TREE_VIEW(priv->torrentTreeView));
+    selection =
+	gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView));
     ids = build_json_id_array(priv->torrentTreeView);
 
     if (confirm_action_dialog(GTK_WINDOW(data), selection,
-            _("<big><b>Remove and delete torrent \"%s\"?</b></big>"),
-            _("<big><b>Remove and delete %d torrents?</b></big>"),
-            GTK_STOCK_DELETE) == GTK_RESPONSE_ACCEPT)
-        dispatch_async(priv->client, torrent_remove(ids, TRUE),
-                on_generic_interactive_action, data);
+			      _
+			      ("<big><b>Remove and delete torrent \"%s\"?</b></big>"),
+			      _
+			      ("<big><b>Remove and delete %d torrents?</b></big>"),
+			      GTK_STOCK_DELETE) == GTK_RESPONSE_ACCEPT)
+	dispatch_async(priv->client, torrent_remove(ids, TRUE),
+		       on_generic_interactive_action, data);
     else
-        json_array_unref(ids);
+	json_array_unref(ids);
 }
 
-static void view_stats_toggled_cb(GtkWidget * w, gpointer data) {
+static void view_stats_toggled_cb(GtkWidget * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
-    TrgStatsDialog *dlg = trg_stats_dialog_get_instance(TRG_MAIN_WINDOW(data),
-            priv->client);
+    TrgStatsDialog *dlg =
+	trg_stats_dialog_get_instance(TRG_MAIN_WINDOW(data),
+				      priv->client);
 
     gtk_widget_show_all(GTK_WIDGET(dlg));
 }
 
-static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data) {
+static void view_states_toggled_cb(GtkCheckMenuItem * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     trg_widget_set_visible(priv->stateSelectorScroller,
-            gtk_check_menu_item_get_active(w));
+			   gtk_check_menu_item_get_active(w));
 }
 
-static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data) {
+static void view_notebook_toggled_cb(GtkCheckMenuItem * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
-    trg_widget_set_visible(priv->notebook, gtk_check_menu_item_get_active(w));
+    trg_widget_set_visible(priv->notebook,
+			   gtk_check_menu_item_get_active(w));
 }
 
 #ifndef TRG_NO_GRAPH
-static void trg_main_window_toggle_graph_cb(GtkCheckMenuItem * w, gpointer win) {
+static void trg_main_window_toggle_graph_cb(GtkCheckMenuItem * w,
+					    gpointer win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     if (gtk_check_menu_item_get_active(w)) {
-        if (priv->graphNotebookIndex < 0)
-            trg_main_window_add_graph(TRG_MAIN_WINDOW(win), TRUE);
+	if (priv->graphNotebookIndex < 0)
+	    trg_main_window_add_graph(TRG_MAIN_WINDOW(win), TRUE);
     } else {
-        if (priv->graphNotebookIndex >= 0)
-            trg_main_window_remove_graph(TRG_MAIN_WINDOW(win));
+	if (priv->graphNotebookIndex >= 0)
+	    trg_main_window_remove_graph(TRG_MAIN_WINDOW(win));
     }
 }
 #endif
 
-void trg_main_window_notebook_set_visible(TrgMainWindow *win, gboolean visible) {
+void trg_main_window_notebook_set_visible(TrgMainWindow * win,
+					  gboolean visible)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     trg_widget_set_visible(priv->notebook, visible);
 }
 
-static GtkWidget *trg_main_window_notebook_new(TrgMainWindow * win) {
+static GtkWidget *trg_main_window_notebook_new(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
 
     GtkWidget *notebook = priv->notebook = gtk_notebook_new();
 
-    priv->genDetails = trg_general_panel_new(
-            GTK_TREE_MODEL(priv->torrentModel), priv->client);
+    priv->genDetails =
+	trg_general_panel_new(GTK_TREE_MODEL(priv->torrentModel),
+			      priv->client);
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            GTK_WIDGET(priv->genDetails), gtk_label_new(_("General")));
+			     GTK_WIDGET(priv->genDetails),
+			     gtk_label_new(_("General")));
 
     priv->trackersModel = trg_trackers_model_new();
-    priv->trackersTreeView = trg_trackers_tree_view_new(priv->trackersModel,
-            priv->client, win);
+    priv->trackersTreeView =
+	trg_trackers_tree_view_new(priv->trackersModel, priv->client, win);
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            my_scrolledwin_new(GTK_WIDGET
-            (priv->trackersTreeView)), gtk_label_new(_("Trackers")));
+			     my_scrolledwin_new(GTK_WIDGET
+						(priv->trackersTreeView)),
+			     gtk_label_new(_("Trackers")));
 
     priv->filesModel = trg_files_model_new();
     priv->filesTreeView = trg_files_tree_view_new(priv->filesModel, win,
-            priv->client);
+						  priv->client);
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            my_scrolledwin_new(GTK_WIDGET
-            (priv->filesTreeView)), gtk_label_new(_("Files")));
+			     my_scrolledwin_new(GTK_WIDGET
+						(priv->filesTreeView)),
+			     gtk_label_new(_("Files")));
 
     priv->peersModel = trg_peers_model_new();
     priv->peersTreeView = trg_peers_tree_view_new(prefs, priv->peersModel);
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            my_scrolledwin_new(GTK_WIDGET
-            (priv->peersTreeView)), gtk_label_new(_("Peers")));
+			     my_scrolledwin_new(GTK_WIDGET
+						(priv->peersTreeView)),
+			     gtk_label_new(_("Peers")));
 
 #ifndef TRG_NO_GRAPH
-    if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_GRAPH, TRG_PREFS_GLOBAL))
-        trg_main_window_add_graph(win, FALSE);
+    if (trg_prefs_get_bool
+	(prefs, TRG_PREFS_KEY_SHOW_GRAPH, TRG_PREFS_GLOBAL))
+	trg_main_window_add_graph(win, FALSE);
     else
-        priv->graphNotebookIndex = -1;
+	priv->graphNotebookIndex = -1;
 #endif
 
     return notebook;
 }
 
-gboolean on_session_set(gpointer data) {
-	trg_response *response = (trg_response*)data;
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+gboolean on_session_set(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
+    TrgMainWindowPrivate *priv =
+	TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
 
-    if (response->status == CURLE_OK || response->status == FAIL_RESPONSE_UNSUCCESSFUL)
-        dispatch_async(priv->client, session_get(), on_session_get, response->cb_data);
+    if (response->status == CURLE_OK
+	|| response->status == FAIL_RESPONSE_UNSUCCESSFUL)
+	dispatch_async(priv->client, session_get(), on_session_get,
+		       response->cb_data);
 
     trg_dialog_error_handler(TRG_MAIN_WINDOW(response->cb_data), response);
     trg_response_free(response);
@@ -834,54 +957,61 @@ gboolean on_session_set(gpointer data) {
     return FALSE;
 }
 
-static gboolean on_session_get(gpointer data) {
-	trg_response *response = (trg_response*)data;
+static gboolean on_session_get(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
     TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+    TrgMainWindowPrivate *priv =
+	TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
     TrgClient *client = priv->client;
     gboolean isConnected = trg_client_is_connected(client);
     JsonObject *newSession = NULL;
 
     if (response->obj)
-        newSession = get_arguments(response->obj);
+	newSession = get_arguments(response->obj);
 
     if (!isConnected) {
-        float version;
-
-        if (trg_dialog_error_handler(win, response) == TRUE) {
-            trg_response_free(response);
-            reset_connect_args(win);
-            return FALSE;
-        }
-
-        if (session_get_version(newSession, &version)==0 || version < TRANSMISSION_MIN_SUPPORTED) {
-            gchar *msg = g_strdup_printf(
-                                    _("This application supports Transmission %.2f and later, you have %.2f."),
-                                    TRANSMISSION_MIN_SUPPORTED, version);
-            GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win),
-                    GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
-                    "%s", msg);
-            gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
-            gtk_dialog_run(GTK_DIALOG(dialog));
-            gtk_widget_destroy(dialog);
-            g_free(msg);
-            trg_response_free(response);
-            reset_connect_args(win);
-            return FALSE;
-        }
-
-        trg_status_bar_connect(priv->statusBar, newSession);
+	float version;
+
+	if (trg_dialog_error_handler(win, response) == TRUE) {
+	    trg_response_free(response);
+	    reset_connect_args(win);
+	    return FALSE;
+	}
+
+	if (session_get_version(newSession, &version) == 0
+	    || version < TRANSMISSION_MIN_SUPPORTED) {
+	    gchar *msg =
+		g_strdup_printf(_
+				("This application supports Transmission %.2f and later, you have %.2f."),
+TRANSMISSION_MIN_SUPPORTED, version);
+	    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win),
+						       GTK_DIALOG_MODAL,
+						       GTK_MESSAGE_ERROR,
+						       GTK_BUTTONS_OK,
+						       "%s", msg);
+	    gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
+	    gtk_dialog_run(GTK_DIALOG(dialog));
+	    gtk_widget_destroy(dialog);
+	    g_free(msg);
+	    trg_response_free(response);
+	    reset_connect_args(win);
+	    return FALSE;
+	}
+
+	trg_status_bar_connect(priv->statusBar, newSession);
     }
 
     if (newSession) {
-        trg_client_set_session(client, newSession);
-        json_object_ref(newSession);
+	trg_client_set_session(client, newSession);
+	json_object_ref(newSession);
     }
 
     if (!isConnected) {
-        trg_main_window_conn_changed(win, TRUE);
-        trg_trackers_tree_view_new_connection(priv->trackersTreeView, client);
-    	dispatch_async(client, torrent_get(-1), on_torrent_get_first, win);
+	trg_main_window_conn_changed(win, TRUE);
+	trg_trackers_tree_view_new_connection(priv->trackersTreeView,
+					      client);
+	dispatch_async(client, torrent_get(-1), on_torrent_get_first, win);
     }
 
     trg_response_free(response);
@@ -889,44 +1019,70 @@ static gboolean on_session_get(gpointer data) {
     return FALSE;
 }
 
-static void connchange_whatever_statusicon(TrgMainWindow *win, gboolean connected)
+static void connchange_whatever_statusicon(TrgMainWindow * win,
+					   gboolean connected)
 {
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     const gchar *display = connected ? _("Connected") : _("Disconnected");
 
 #ifdef HAVE_LIBAPPINDICATOR
     if (priv->appIndicator)
-      app_indicator_set_menu(priv->appIndicator, trg_status_icon_view_menu(win, display));
+	app_indicator_set_menu(priv->appIndicator,
+			       trg_status_icon_view_menu(win, display));
 #else
     if (priv->statusIcon)
-      gtk_status_icon_set_tooltip_text(priv->statusIcon, display);
+	gtk_status_icon_set_tooltip_text(priv->statusIcon, display);
 #endif
 }
 
-static void update_whatever_statusicon(TrgMainWindow *win, const gchar *speedLabel, trg_torrent_model_update_stats *stats)
+static void update_whatever_statusicon(TrgMainWindow * win,
+				       const gchar * speedLabel,
+				       trg_torrent_model_update_stats *
+				       stats)
 {
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
-    gchar *display = g_strdup_printf("%s: %s", _("Connected"), speedLabel);
 
 #ifdef HAVE_LIBAPPINDICATOR
+    gtk_widget_set_visible(priv->appIndicatorSeedingItem, stats != NULL);
+    gtk_widget_set_visible(priv->appIndicatorDownloadingItem,
+			   stats != NULL);
+    gtk_widget_set_visible(priv->appIndicatorSepItem, stats != NULL);
+
+    if (stats) {
+	gchar *downloadingLabel =
+	    g_strdup_printf(_("Downloading  %d"), stats->down);
+	gchar *seedingLabel =
+	    g_strdup_printf(_("Seeding  %d"), stats->seeding);
+	gtk_menu_item_set_label(GTK_MENU_ITEM
+				(priv->appIndicatorSeedingItem),
+				seedingLabel);
+	gtk_menu_item_set_label(GTK_MENU_ITEM
+				(priv->appIndicatorDownloadingItem),
+				downloadingLabel);
+	g_free(downloadingLabel);
+	g_free(seedingLabel);
+    }
+
     if (priv->appIndicatorStatusItem)
-      gtk_menu_item_set_label(GTK_MENU_ITEM(priv->appIndicatorStatusItem), display);
+	gtk_menu_item_set_label(GTK_MENU_ITEM
+				(priv->appIndicatorStatusItem),
+				speedLabel);
 #else
     if (priv->statusIcon)
-      gtk_status_icon_set_tooltip_text(priv->statusIcon, display); 
+	gtk_status_icon_set_tooltip_text(priv->statusIcon, speedLabel);
 #endif
-
-    g_free(display);
 }
 
-/*
- * The callback for a torrent-get response.
- */
+	/*
+	 * The callback for a torrent-get response.
+	 */
 
-static gboolean on_torrent_get(gpointer data, int mode) {
-	trg_response *response = (trg_response*)data;
-	TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+static gboolean on_torrent_get(gpointer data, int mode)
+{
+    trg_response *response = (trg_response *) data;
+    TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
+    TrgMainWindowPrivate *priv =
+	TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
     TrgClient *client = priv->client;
     TrgPrefs *prefs = trg_client_get_prefs(client);
     trg_torrent_model_update_stats *stats;
@@ -934,110 +1090,138 @@ static gboolean on_torrent_get(gpointer data, int mode) {
 
     /* Disconnected between request and response callback */
     if (!trg_client_is_connected(client)) {
-        trg_response_free(response);
-        return FALSE;
+	trg_response_free(response);
+	return FALSE;
     }
 
     trg_client_updatelock(client);
 
     interval
-            = gtk_widget_get_visible(GTK_WIDGET(win)) ? trg_prefs_get_int(prefs,
-                    TRG_PREFS_KEY_UPDATE_INTERVAL, TRG_PREFS_CONNECTION)
-                    : trg_prefs_get_int(prefs,
-                            TRG_PREFS_KEY_MINUPDATE_INTERVAL, TRG_PREFS_CONNECTION);
+	=
+	gtk_widget_get_visible(GTK_WIDGET(win)) ? trg_prefs_get_int(prefs,
+								    TRG_PREFS_KEY_UPDATE_INTERVAL,
+								    TRG_PREFS_CONNECTION)
+	: trg_prefs_get_int(prefs, TRG_PREFS_KEY_MINUPDATE_INTERVAL,
+			    TRG_PREFS_CONNECTION);
     if (interval < 1)
-        interval = TRG_INTERVAL_DEFAULT;
+	interval = TRG_INTERVAL_DEFAULT;
 
     if (response->status != CURLE_OK) {
-        if (trg_client_inc_failcount(client) >= TRG_MAX_RETRIES) {
-            trg_main_window_conn_changed(win, FALSE);
-            trg_dialog_error_handler(win, response);
-        } else {
-            gchar *msg = make_error_message(response->obj, response->status);
-            gchar *statusBarMsg = g_strdup_printf(_("Request %d/%d failed: %s"),
-                    trg_client_get_failcount(client), TRG_MAX_RETRIES, msg);
-            trg_status_bar_push_connection_msg(priv->statusBar, statusBarMsg);
-            g_free(msg);
-            g_free(statusBarMsg);
-            priv->timerId = g_timeout_add_seconds(interval, trg_update_torrents_timerfunc, win);
-        }
-        trg_client_updateunlock(client);
-        trg_response_free(response);
-        return FALSE;
+	if (trg_client_inc_failcount(client) >= TRG_MAX_RETRIES) {
+	    trg_main_window_conn_changed(win, FALSE);
+	    trg_dialog_error_handler(win, response);
+	} else {
+	    gchar *msg =
+		make_error_message(response->obj, response->status);
+	    gchar *statusBarMsg =
+		g_strdup_printf(_("Request %d/%d failed: %s"),
+				trg_client_get_failcount(client),
+				TRG_MAX_RETRIES, msg);
+	    trg_status_bar_push_connection_msg(priv->statusBar,
+					       statusBarMsg);
+	    g_free(msg);
+	    g_free(statusBarMsg);
+	    priv->timerId =
+		g_timeout_add_seconds(interval,
+				      trg_update_torrents_timerfunc, win);
+	}
+	trg_client_updateunlock(client);
+	trg_response_free(response);
+	return FALSE;
     }
 
     trg_client_reset_failcount(client);
     trg_client_inc_serial(client);
 
-    stats = trg_torrent_model_update(priv->torrentModel, client, response->obj, mode);
+    stats =
+	trg_torrent_model_update(priv->torrentModel, client, response->obj,
+				 mode);
     trg_state_selector_stats_update(priv->stateSelector, stats);
     update_selected_torrent_notebook(win, mode, priv->selectedTorrentId);
     trg_status_bar_update(priv->statusBar, stats, client);
-    update_whatever_statusicon(win, trg_status_bar_get_speed_text(priv->statusBar), stats);
+    update_whatever_statusicon(win,
+			       trg_status_bar_get_speed_text(priv->
+							     statusBar),
+			       stats);
 
 #ifndef TRG_NO_GRAPH
     if (priv->graphNotebookIndex >= 0)
-        trg_torrent_graph_set_speed(priv->graph, stats);
+	trg_torrent_graph_set_speed(priv->graph, stats);
 #endif
 
     if (mode != TORRENT_GET_MODE_INTERACTION)
-        priv->timerId = g_timeout_add_seconds(interval, trg_update_torrents_timerfunc, win);
+	priv->timerId =
+	    g_timeout_add_seconds(interval, trg_update_torrents_timerfunc,
+				  win);
 
     trg_client_updateunlock(client);
     trg_response_free(response);
     return FALSE;
 }
 
-static gboolean on_torrent_get_active(gpointer data) {
+static gboolean on_torrent_get_active(gpointer data)
+{
     return on_torrent_get(data, TORRENT_GET_MODE_ACTIVE);
 }
 
-static gboolean on_torrent_get_first(gpointer data) {
-    trg_response *response = (trg_response*)data;
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+static gboolean on_torrent_get_first(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
+    TrgMainWindowPrivate *priv =
+	TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
     TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
 
     gboolean result = on_torrent_get(data, TORRENT_GET_MODE_FIRST);
 
     if (priv->args)
-        trg_add_from_filename(win, priv->args);
+	trg_add_from_filename(win, priv->args);
 
     return result;
 }
 
-static gboolean on_torrent_get_interactive(gpointer data) {
+static gboolean on_torrent_get_interactive(gpointer data)
+{
     return on_torrent_get(data, TORRENT_GET_MODE_INTERACTION);
 }
 
-static gboolean on_torrent_get_update(gpointer data) {
+static gboolean on_torrent_get_update(gpointer data)
+{
     return on_torrent_get(data, TORRENT_GET_MODE_UPDATE);
 }
 
-static gboolean trg_update_torrents_timerfunc(gpointer data) {
+static gboolean trg_update_torrents_timerfunc(gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     TrgClient *tc = priv->client;
     TrgPrefs *prefs = trg_client_get_prefs(tc);
 
     if (trg_client_is_connected(tc)) {
-        gboolean activeOnly = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, TRG_PREFS_CONNECTION)
-                && (!trg_prefs_get_bool(prefs,
-                        TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED,
-                        TRG_PREFS_CONNECTION) || (trg_client_get_serial(tc)
-                        % trg_prefs_get_int(prefs,
-                                TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY,
-                                TRG_PREFS_CONNECTION) != 0));
-        dispatch_async(tc, torrent_get(activeOnly ? TORRENT_GET_TAG_MODE_UPDATE : TORRENT_GET_TAG_MODE_FULL),
-                activeOnly ? on_torrent_get_active : on_torrent_get_update,
-                data);
-
-        if (trg_client_get_serial(tc) % SESSION_UPDATE_DIVISOR == 0)
-            dispatch_async(priv->client, session_get(), on_session_get, data);
+	gboolean activeOnly =
+	    trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY,
+			       TRG_PREFS_CONNECTION)
+	    && (!trg_prefs_get_bool(prefs,
+				    TRG_PREFS_ACTIVEONLY_FULLSYNC_ENABLED,
+				    TRG_PREFS_CONNECTION)
+		|| (trg_client_get_serial(tc)
+		    % trg_prefs_get_int(prefs,
+					TRG_PREFS_ACTIVEONLY_FULLSYNC_EVERY,
+					TRG_PREFS_CONNECTION) != 0));
+	dispatch_async(tc,
+		       torrent_get(activeOnly ? TORRENT_GET_TAG_MODE_UPDATE
+				   : TORRENT_GET_TAG_MODE_FULL),
+		       activeOnly ? on_torrent_get_active :
+		       on_torrent_get_update, data);
+
+	if (trg_client_get_serial(tc) % SESSION_UPDATE_DIVISOR == 0)
+	    dispatch_async(priv->client, session_get(), on_session_get,
+			   data);
     }
 
     return FALSE;
 }
 
-static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent) {
+static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent)
+{
     GtkWidget *aboutDialog = trg_about_window_new(parent);
 
     gtk_dialog_run(GTK_DIALOG(aboutDialog));
@@ -1045,7 +1229,9 @@ static void open_about_cb(GtkWidget * w G_GNUC_UNUSED, GtkWindow * parent) {
 }
 
 static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model,
-        GtkTreeIter * iter, gpointer data) {
+						   GtkTreeIter * iter,
+						   gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     guint flags;
@@ -1058,100 +1244,110 @@ static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model,
     gtk_tree_model_get(model, iter, TORRENT_COLUMN_FLAGS, &flags, -1);
 
     if (criteria != 0) {
-        if (criteria & FILTER_FLAG_TRACKER) {
-            gchar *text = trg_state_selector_get_selected_text(
-                    priv->stateSelector);
-            JsonObject *json;
-            gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json, -1);
-
-            if (!json || !torrent_has_tracker(json,
-                    trg_state_selector_get_url_host_regex(priv->stateSelector),
-                    text))
-                return FALSE;
-        } else if (criteria & FILTER_FLAG_DIR) {
-            gchar *text = trg_state_selector_get_selected_text(
-                    priv->stateSelector);
-            gchar *dd;
-            int cmp;
-            gtk_tree_model_get(model, iter, TORRENT_COLUMN_DOWNLOADDIR_SHORT, &dd, -1);
-            cmp = g_strcmp0(text, dd);
-            g_free(dd);
-            g_free(text);
-            if (cmp)
-                return FALSE;
-        } else if (!(flags & criteria)) {
-            return FALSE;
-        }
+	if (criteria & FILTER_FLAG_TRACKER) {
+	    gchar *text =
+		trg_state_selector_get_selected_text(priv->stateSelector);
+	    JsonObject *json;
+	    gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json,
+			       -1);
+
+	    if (!json || !torrent_has_tracker(json,
+					      trg_state_selector_get_url_host_regex
+					      (priv->stateSelector), text))
+		return FALSE;
+	} else if (criteria & FILTER_FLAG_DIR) {
+	    gchar *text =
+		trg_state_selector_get_selected_text(priv->stateSelector);
+	    gchar *dd;
+	    int cmp;
+	    gtk_tree_model_get(model, iter,
+			       TORRENT_COLUMN_DOWNLOADDIR_SHORT, &dd, -1);
+	    cmp = g_strcmp0(text, dd);
+	    g_free(dd);
+	    g_free(text);
+	    if (cmp)
+		return FALSE;
+	} else if (!(flags & criteria)) {
+	    return FALSE;
+	}
     }
 
     visible = TRUE;
 
     filterText = gtk_entry_get_text(GTK_ENTRY(priv->filterEntry));
     if (strlen(filterText) > 0) {
-        gtk_tree_model_get(model, iter, TORRENT_COLUMN_NAME, &name, -1);
-        if (name) {
-            gchar *filterCmp = g_utf8_casefold(filterText, -1);
-            gchar *nameCmp = g_utf8_casefold(name, -1);
-
-            if (!strstr(nameCmp, filterCmp))
-                visible = FALSE;
-
-            g_free(nameCmp);
-            g_free(filterCmp);
-            g_free(name);
-        }
+	gtk_tree_model_get(model, iter, TORRENT_COLUMN_NAME, &name, -1);
+	if (name) {
+	    gchar *filterCmp = g_utf8_casefold(filterText, -1);
+	    gchar *nameCmp = g_utf8_casefold(name, -1);
+
+	    if (!strstr(nameCmp, filterCmp))
+		visible = FALSE;
+
+	    g_free(nameCmp);
+	    g_free(filterCmp);
+	    g_free(name);
+	}
     }
 
     return visible;
 }
 
-void trg_main_window_reload_dir_aliases(TrgMainWindow *win)
+void trg_main_window_reload_dir_aliases(TrgMainWindow * win)
 {
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
-    trg_torrent_model_reload_dir_aliases(priv->client, GTK_TREE_MODEL(priv->torrentModel));
+    trg_torrent_model_reload_dir_aliases(priv->client,
+					 GTK_TREE_MODEL(priv->
+							torrentModel));
     trg_state_selector_update(priv->stateSelector);
 }
 
-static TrgTorrentTreeView *trg_main_window_torrent_tree_view_new(
-        TrgMainWindow * win, GtkTreeModel * model) {
+static TrgTorrentTreeView
+    *trg_main_window_torrent_tree_view_new(TrgMainWindow * win,
+					   GtkTreeModel * model)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
-    TrgTorrentTreeView *torrentTreeView = trg_torrent_tree_view_new(
-            trg_client_get_prefs(priv->client), model);
+    TrgTorrentTreeView *torrentTreeView =
+	trg_torrent_tree_view_new(trg_client_get_prefs(priv->client),
+				  model);
 
-    GtkTreeSelection *selection = gtk_tree_view_get_selection(
-            GTK_TREE_VIEW(torrentTreeView));
+    GtkTreeSelection *selection =
+	gtk_tree_view_get_selection(GTK_TREE_VIEW(torrentTreeView));
 
     g_signal_connect(G_OBJECT(selection), "changed",
-            G_CALLBACK(torrent_selection_changed), win);
+		     G_CALLBACK(torrent_selection_changed), win);
 
     return torrentTreeView;
 }
 
 static gboolean trg_dialog_error_handler(TrgMainWindow * win,
-        trg_response *response) {
+					 trg_response * response)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
     if (response->status != CURLE_OK) {
-        GtkWidget *dialog;
-        const gchar *msg;
-
-        msg = make_error_message(response->obj, response->status);
-        trg_status_bar_clear_indicators(priv->statusBar);
-        trg_status_bar_push_connection_msg(priv->statusBar, msg);
-        dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_MODAL,
-                GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", msg);
-        gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
-        gtk_dialog_run(GTK_DIALOG(dialog));
-        gtk_widget_destroy(dialog);
-        g_free((gpointer) msg);
-        return TRUE;
+	GtkWidget *dialog;
+	const gchar *msg;
+
+	msg = make_error_message(response->obj, response->status);
+	trg_status_bar_clear_indicators(priv->statusBar);
+	trg_status_bar_push_connection_msg(priv->statusBar, msg);
+	dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_MODAL,
+					GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
+					"%s", msg);
+	gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
+	gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	g_free((gpointer) msg);
+	return TRUE;
     } else {
-        return FALSE;
+	return FALSE;
     }
 }
 
 static gboolean torrent_selection_changed(GtkTreeSelection * selection,
-        gpointer data) {
+					  gpointer data)
+{
     TrgMainWindow *win = TRG_MAIN_WINDOW(data);
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     GList *selectionList;
@@ -1159,8 +1355,8 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection,
     gint64 id;
 
     if (trg_torrent_model_is_remove_in_progress(priv->torrentModel)) {
-        trg_main_window_torrent_scrub(win);
-        return TRUE;
+	trg_main_window_torrent_scrub(win);
+	return TRUE;
     }
 
     selectionList = gtk_tree_selection_get_selected_rows(selection, NULL);
@@ -1168,12 +1364,12 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection,
     id = -1;
 
     if (firstNode) {
-        GtkTreeIter iter;
-        if (gtk_tree_model_get_iter(priv->filteredTorrentModel, &iter,
-                (GtkTreePath *) firstNode->data)) {
-            gtk_tree_model_get(priv->filteredTorrentModel, &iter,
-                    TORRENT_COLUMN_ID, &id, -1);
-        }
+	GtkTreeIter iter;
+	if (gtk_tree_model_get_iter(priv->filteredTorrentModel, &iter,
+				    (GtkTreePath *) firstNode->data)) {
+	    gtk_tree_model_get(priv->filteredTorrentModel, &iter,
+			       TORRENT_COLUMN_ID, &id, -1);
+	}
     }
 
     g_list_foreach(selectionList, (GFunc) gtk_tree_path_free, NULL);
@@ -1184,27 +1380,32 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection,
     return TRUE;
 }
 
-gboolean on_generic_interactive_action(gpointer data) {
-	trg_response *response = (trg_response*)data;
-	TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+gboolean on_generic_interactive_action(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
+    TrgMainWindow *win = TRG_MAIN_WINDOW(response->cb_data);
+    TrgMainWindowPrivate *priv =
+	TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
     TrgClient *tc = priv->client;
     TrgPrefs *prefs = trg_client_get_prefs(tc);
 
     if (trg_client_is_connected(tc)) {
-        trg_dialog_error_handler(win, response);
-
-        if (response->status == CURLE_OK) {
-            gint64 id;
-            if (json_object_has_member(response->obj, PARAM_TAG))
-                id = json_object_get_int_member(response->obj, PARAM_TAG);
-            else if (trg_prefs_get_bool(prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY, TRG_PREFS_CONNECTION))
-                id = -2;
-            else
-                id = -1;
-
-            dispatch_async(tc, torrent_get(id), on_torrent_get_interactive, win);
-        }
+	trg_dialog_error_handler(win, response);
+
+	if (response->status == CURLE_OK) {
+	    gint64 id;
+	    if (json_object_has_member(response->obj, PARAM_TAG))
+		id = json_object_get_int_member(response->obj, PARAM_TAG);
+	    else if (trg_prefs_get_bool
+		     (prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY,
+		      TRG_PREFS_CONNECTION))
+		id = -2;
+	    else
+		id = -1;
+
+	    dispatch_async(tc, torrent_get(id), on_torrent_get_interactive,
+			   win);
+	}
     }
 
     trg_response_free(response);
@@ -1212,7 +1413,8 @@ gboolean on_generic_interactive_action(gpointer data) {
 }
 
 static
-void trg_main_window_torrent_scrub(TrgMainWindow * win) {
+void trg_main_window_torrent_scrub(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
     gtk_list_store_clear(GTK_LIST_STORE(priv->filesModel));
@@ -1220,30 +1422,35 @@ void trg_main_window_torrent_scrub(TrgMainWindow * win) {
     gtk_list_store_clear(GTK_LIST_STORE(priv->peersModel));
     trg_general_panel_clear(priv->genDetails);
     trg_trackers_model_set_no_selection(TRG_TRACKERS_MODEL
-    (priv->trackersModel));
+					(priv->trackersModel));
 
     trg_toolbar_torrent_actions_sensitive(priv->toolBar, FALSE);
     trg_menu_bar_torrent_actions_sensitive(priv->menuBar, FALSE);
 }
 
-static void entry_filter_changed_cb(GtkWidget * w, gpointer data) {
+static void entry_filter_changed_cb(GtkWidget * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     gboolean clearSensitive = gtk_entry_get_text_length(GTK_ENTRY(w)) > 0;
 
     gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER
-    (priv->filteredTorrentModel));
+				   (priv->filteredTorrentModel));
 
     g_object_set(priv->filterEntry, "secondary-icon-sensitive",
-            clearSensitive, NULL);
+		 clearSensitive, NULL);
 }
 
-static void torrent_state_selection_changed(TrgStateSelector * selector G_GNUC_UNUSED,
-        guint flag G_GNUC_UNUSED, gpointer data) {
+static void torrent_state_selection_changed(TrgStateSelector *
+					    selector G_GNUC_UNUSED,
+					    guint flag G_GNUC_UNUSED,
+					    gpointer data)
+{
     gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(data));
 }
 
 static
-void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected) {
+void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgClient *tc = priv->client;
 
@@ -1253,143 +1460,157 @@ void trg_main_window_conn_changed(TrgMainWindow * win, gboolean connected) {
     gtk_widget_set_sensitive(GTK_WIDGET(priv->torrentTreeView), connected);
     gtk_widget_set_sensitive(GTK_WIDGET(priv->peersTreeView), connected);
     gtk_widget_set_sensitive(GTK_WIDGET(priv->filesTreeView), connected);
-    gtk_widget_set_sensitive(GTK_WIDGET(priv->trackersTreeView), connected);
+    gtk_widget_set_sensitive(GTK_WIDGET(priv->trackersTreeView),
+			     connected);
     gtk_widget_set_sensitive(GTK_WIDGET(priv->genDetails), connected);
 
     if (!connected) {
-        trg_main_window_torrent_scrub(win);
-        trg_state_selector_disconnect(priv->stateSelector);
+	trg_main_window_torrent_scrub(win);
+	trg_state_selector_disconnect(priv->stateSelector);
 
 #ifndef TRG_NO_GRAPH
-        if (priv->graphNotebookIndex >= 0)
-            trg_torrent_graph_set_nothing(priv->graph);
+	if (priv->graphNotebookIndex >= 0)
+	    trg_torrent_graph_set_nothing(priv->graph);
 #endif
 
-        trg_torrent_model_remove_all(priv->torrentModel);
+	trg_torrent_model_remove_all(priv->torrentModel);
 
-        priv->timerId = 0;
+	priv->timerId = 0;
     }
 
     trg_client_status_change(tc, connected);
     connchange_whatever_statusicon(win, connected);
 }
 
-static void trg_main_window_get_property(GObject * object, guint property_id,
-        GValue * value, GParamSpec * pspec) {
+static void trg_main_window_get_property(GObject * object,
+					 guint property_id, GValue * value,
+					 GParamSpec * pspec)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(object);
     switch (property_id) {
     case PROP_CLIENT:
-        g_value_set_pointer(value, priv->client);
-        break;
+	g_value_set_pointer(value, priv->client);
+	break;
     case PROP_MINIMISE_ON_START:
-        g_value_set_boolean(value, priv->min_on_start);
-        break;
+	g_value_set_boolean(value, priv->min_on_start);
+	break;
     default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
-        break;
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+	break;
     }
 }
 
-static void trg_main_window_set_property(GObject * object, guint property_id,
-        const GValue * value, GParamSpec * pspec) {
+static void trg_main_window_set_property(GObject * object,
+					 guint property_id,
+					 const GValue * value,
+					 GParamSpec * pspec)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(object);
     switch (property_id) {
     case PROP_CLIENT:
-        priv->client = g_value_get_pointer(value);
-        break;
+	priv->client = g_value_get_pointer(value);
+	break;
     case PROP_MINIMISE_ON_START:
-        priv->min_on_start = g_value_get_boolean(value);
-        break;
+	priv->min_on_start = g_value_get_boolean(value);
+	break;
     default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
-        break;
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+	break;
     }
 }
 
-static void quit_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void quit_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     gtk_widget_destroy(GTK_WIDGET(data));
 }
 
-static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) {
+static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
     GObject *b_disconnect, *b_add, *b_resume, *b_pause, *b_verify,
-            *b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs,
-            *b_about, *b_view_states, *b_view_notebook, *b_view_stats,
-            *b_add_url, *b_quit, *b_move, *b_reannounce, *b_pause_all,
-            *b_resume_all, *b_dir_filters, *b_tracker_filters,
-            *b_up_queue, *b_down_queue, *b_top_queue, *b_bottom_queue,
+	*b_remove, *b_delete, *b_props, *b_local_prefs, *b_remote_prefs,
+	*b_about, *b_view_states, *b_view_notebook, *b_view_stats,
+	*b_add_url, *b_quit, *b_move, *b_reannounce, *b_pause_all,
+	*b_resume_all, *b_dir_filters, *b_tracker_filters,
+	*b_up_queue, *b_down_queue, *b_top_queue, *b_bottom_queue,
 #ifndef TRG_NO_GRAPH
-	    *b_show_graph,
+    *b_show_graph,
 #endif
-            *b_start_now;
+    *b_start_now;
 
     TrgMenuBar *menuBar;
 
     menuBar = trg_menu_bar_new(win, trg_client_get_prefs(priv->client));
     g_object_get(menuBar, "disconnect-button",
-            &b_disconnect, "add-button", &b_add, "add-url-button", &b_add_url,
-            "resume-button", &b_resume, "resume-all-button", &b_resume_all,
-            "pause-button", &b_pause, "pause-all-button", &b_pause_all,
-            "delete-button", &b_delete, "remove-button", &b_remove,
-            "move-button", &b_move, "verify-button", &b_verify,
-            "reannounce-button", &b_reannounce, "props-button", &b_props,
-            "remote-prefs-button", &b_remote_prefs, "local-prefs-button",
-            &b_local_prefs, "view-notebook-button", &b_view_notebook,
-            "view-states-button", &b_view_states, "view-stats-button",
-            &b_view_stats, "about-button", &b_about, "quit-button", &b_quit,
-            "dir-filters", &b_dir_filters, "tracker-filters",
-            &b_tracker_filters,
+		 &b_disconnect, "add-button", &b_add, "add-url-button",
+		 &b_add_url, "resume-button", &b_resume,
+		 "resume-all-button", &b_resume_all, "pause-button",
+		 &b_pause, "pause-all-button", &b_pause_all,
+		 "delete-button", &b_delete, "remove-button", &b_remove,
+		 "move-button", &b_move, "verify-button", &b_verify,
+		 "reannounce-button", &b_reannounce, "props-button",
+		 &b_props, "remote-prefs-button", &b_remote_prefs,
+		 "local-prefs-button", &b_local_prefs,
+		 "view-notebook-button", &b_view_notebook,
+		 "view-states-button", &b_view_states, "view-stats-button",
+		 &b_view_stats, "about-button", &b_about, "quit-button",
+		 &b_quit, "dir-filters", &b_dir_filters, "tracker-filters",
+		 &b_tracker_filters,
 #ifndef TRG_NO_GRAPH
-	    "show-graph", &b_show_graph,
+		 "show-graph", &b_show_graph,
 #endif
-	    "up-queue", &b_up_queue, "down-queue", &b_down_queue, "top-queue",
-            &b_top_queue, "bottom-queue", &b_bottom_queue, "start-now",
-            &b_start_now, NULL);
+		 "up-queue", &b_up_queue, "down-queue", &b_down_queue,
+		 "top-queue", &b_top_queue, "bottom-queue",
+		 &b_bottom_queue, "start-now", &b_start_now, NULL);
 
     g_signal_connect(b_disconnect, "activate",
-            G_CALLBACK(disconnect_cb), win);
+		     G_CALLBACK(disconnect_cb), win);
     g_signal_connect(b_add, "activate", G_CALLBACK(add_cb), win);
     g_signal_connect(b_add_url, "activate", G_CALLBACK(add_url_cb), win);
     g_signal_connect(b_resume, "activate", G_CALLBACK(resume_cb), win);
     g_signal_connect(b_resume_all, "activate", G_CALLBACK(resume_all_cb),
-            win);
+		     win);
     g_signal_connect(b_pause, "activate", G_CALLBACK(pause_cb), win);
     g_signal_connect(b_pause_all, "activate", G_CALLBACK(pause_all_cb),
-            win);
+		     win);
     g_signal_connect(b_verify, "activate", G_CALLBACK(verify_cb), win);
     g_signal_connect(b_reannounce, "activate", G_CALLBACK(reannounce_cb),
-            win);
+		     win);
     g_signal_connect(b_delete, "activate", G_CALLBACK(delete_cb), win);
     g_signal_connect(b_remove, "activate", G_CALLBACK(remove_cb), win);
     g_signal_connect(b_up_queue, "activate", G_CALLBACK(up_queue_cb), win);
-    g_signal_connect(b_down_queue, "activate", G_CALLBACK(down_queue_cb), win);
-    g_signal_connect(b_top_queue, "activate", G_CALLBACK(top_queue_cb), win);
-    g_signal_connect(b_bottom_queue, "activate", G_CALLBACK(bottom_queue_cb), win);
-    g_signal_connect(b_start_now, "activate", G_CALLBACK(start_now_cb), win);
+    g_signal_connect(b_down_queue, "activate", G_CALLBACK(down_queue_cb),
+		     win);
+    g_signal_connect(b_top_queue, "activate", G_CALLBACK(top_queue_cb),
+		     win);
+    g_signal_connect(b_bottom_queue, "activate",
+		     G_CALLBACK(bottom_queue_cb), win);
+    g_signal_connect(b_start_now, "activate", G_CALLBACK(start_now_cb),
+		     win);
     g_signal_connect(b_move, "activate", G_CALLBACK(move_cb), win);
     g_signal_connect(b_about, "activate", G_CALLBACK(open_about_cb), win);
     g_signal_connect(b_local_prefs, "activate",
-            G_CALLBACK(open_local_prefs_cb), win);
+		     G_CALLBACK(open_local_prefs_cb), win);
     g_signal_connect(b_remote_prefs, "activate",
-            G_CALLBACK(open_remote_prefs_cb), win);
+		     G_CALLBACK(open_remote_prefs_cb), win);
     g_signal_connect(b_view_notebook, "toggled",
-            G_CALLBACK(view_notebook_toggled_cb), win);
+		     G_CALLBACK(view_notebook_toggled_cb), win);
     g_signal_connect(b_dir_filters, "toggled",
-            G_CALLBACK(main_window_toggle_filter_dirs), win);
+		     G_CALLBACK(main_window_toggle_filter_dirs), win);
     g_signal_connect(b_tracker_filters, "toggled",
-            G_CALLBACK(main_window_toggle_filter_trackers), win);
+		     G_CALLBACK(main_window_toggle_filter_trackers), win);
 #ifndef TRG_NO_GRAPH
     g_signal_connect(b_tracker_filters, "toggled",
-            G_CALLBACK(trg_main_window_toggle_graph_cb), win);
+		     G_CALLBACK(trg_main_window_toggle_graph_cb), win);
 #endif
     g_signal_connect(b_view_states, "toggled",
-            G_CALLBACK(view_states_toggled_cb), win);
+		     G_CALLBACK(view_states_toggled_cb), win);
     g_signal_connect(b_view_stats, "activate",
-            G_CALLBACK(view_stats_toggled_cb), win);
+		     G_CALLBACK(view_stats_toggled_cb), win);
 #ifndef TRG_NO_GRAPH
     g_signal_connect(b_show_graph, "toggled",
-            G_CALLBACK(trg_main_window_toggle_graph_cb), win);
+		     G_CALLBACK(trg_main_window_toggle_graph_cb), win);
 #endif
     g_signal_connect(b_props, "activate", G_CALLBACK(open_props_cb), win);
     g_signal_connect(b_quit, "activate", G_CALLBACK(quit_cb), win);
@@ -1398,23 +1619,27 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) {
 }
 
 #ifndef HAVE_LIBAPPINDICATOR
-static void status_icon_activated(GtkStatusIcon * icon G_GNUC_UNUSED, gpointer data) {
+static void status_icon_activated(GtkStatusIcon * icon G_GNUC_UNUSED,
+				  gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     gtk_window_deiconify(GTK_WINDOW(data));
     gtk_window_present(GTK_WINDOW(data));
 
-    if (priv->timerId > 0)
-    {
-        g_source_remove(priv->timerId);
-        dispatch_async(priv->client, torrent_get(TORRENT_GET_TAG_MODE_FULL),
-                on_torrent_get_first, data);
+    if (priv->timerId > 0) {
+	g_source_remove(priv->timerId);
+	dispatch_async(priv->client,
+		       torrent_get(TORRENT_GET_TAG_MODE_FULL),
+		       on_torrent_get_first, data);
     }
 }
 
 static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon,
-        gpointer userdata) {
-    GtkMenu *menu = trg_status_icon_view_menu(TRG_MAIN_WINDOW(userdata), NULL);
+					      gpointer userdata)
+{
+    GtkMenu *menu =
+	trg_status_icon_view_menu(TRG_MAIN_WINDOW(userdata), NULL);
 
     gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, 0);
 
@@ -1422,48 +1647,59 @@ static gboolean trg_status_icon_popup_menu_cb(GtkStatusIcon * icon,
 }
 
 static gboolean status_icon_button_press_event(GtkStatusIcon * icon,
-        GdkEventButton * event, gpointer data) {
+					       GdkEventButton * event,
+					       gpointer data)
+{
     if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
-        GtkMenu *menu = trg_status_icon_view_menu(TRG_MAIN_WINDOW(data), NULL);
-        gtk_menu_popup(menu, NULL, NULL, NULL, NULL, (event != NULL) ? event->button : 0, gdk_event_get_time((GdkEvent *) event));
-        return TRUE;
+	GtkMenu *menu =
+	    trg_status_icon_view_menu(TRG_MAIN_WINDOW(data), NULL);
+	gtk_menu_popup(menu, NULL, NULL, NULL, NULL,
+		       (event != NULL) ? event->button : 0,
+		       gdk_event_get_time((GdkEvent *) event));
+	return TRUE;
     } else {
-        return FALSE;
+	return FALSE;
     }
 }
 #endif
 
-static void clear_filter_entry_cb(GtkEntry *entry,
-        GtkEntryIconPosition icon_pos,
-        GdkEvent            *event,
-        gpointer             user_data)
+static void clear_filter_entry_cb(GtkEntry * entry,
+				  GtkEntryIconPosition icon_pos,
+				  GdkEvent * event, gpointer user_data)
 {
     gtk_entry_set_text(entry, "");
 }
 
-static gboolean torrent_tv_key_press_event(GtkWidget * w, GdkEventKey * key,
-        gpointer data) {
+static gboolean torrent_tv_key_press_event(GtkWidget * w,
+					   GdkEventKey * key,
+					   gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     if (key->keyval == GDK_Delete) {
-        if (key->state & GDK_SHIFT_MASK)
-            delete_cb(w, data);
-        else
-            remove_cb(w, data);
-    } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) && key->keyval == GDK_Up) {
-        up_queue_cb(w, data);
-    } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK) && key->keyval == GDK_Down) {
-        down_queue_cb(w, data);
+	if (key->state & GDK_SHIFT_MASK)
+	    delete_cb(w, data);
+	else
+	    remove_cb(w, data);
+    } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK)
+	       && key->keyval == GDK_Up) {
+	up_queue_cb(w, data);
+    } else if (priv->queuesEnabled && (key->state & GDK_MOD1_MASK)
+	       && key->keyval == GDK_Down) {
+	down_queue_cb(w, data);
     }
     return FALSE;
 }
 
-static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text,
-        char *stock_id, gboolean sensitive, GCallback cb, gpointer cbdata) {
+static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell,
+					const gchar * text, char *stock_id,
+					gboolean sensitive, GCallback cb,
+					gpointer cbdata)
+{
     GtkWidget *item = gtk_image_menu_item_new_with_label(stock_id);
 
     gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(item), TRUE);
     gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
-    (item), TRUE);
+					      (item), TRUE);
     gtk_menu_item_set_label(GTK_MENU_ITEM(item), text);
     g_signal_connect(item, "activate", cb, cbdata);
     gtk_widget_set_sensitive(item, sensitive);
@@ -1472,7 +1708,8 @@ static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell, const gchar *text,
     return item;
 }
 
-static void set_limit_cb(GtkWidget * w, gpointer data) {
+static void set_limit_cb(GtkWidget * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     GtkWidget *parent = gtk_widget_get_parent(w);
@@ -1486,38 +1723,41 @@ static void set_limit_cb(GtkWidget * w, gpointer data) {
     JsonObject *args;
 
     if (limitIds)
-        req = torrent_set((JsonArray *) limitIds);
+	req = torrent_set((JsonArray *) limitIds);
     else
-        req = session_set();
+	req = session_set();
 
     args = node_get_arguments(req);
 
     if (speed >= 0)
-        json_object_set_int_member(args, speedKey, speed);
+	json_object_set_int_member(args, speedKey, speed);
 
     json_object_set_boolean_member(args, enabledKey, speed >= 0);
 
     if (limitIds)
-        dispatch_async(priv->client, req, on_generic_interactive_action, data);
+	dispatch_async(priv->client, req, on_generic_interactive_action,
+		       data);
     else
-        dispatch_async(priv->client, req, on_session_set, data);
+	dispatch_async(priv->client, req, on_session_set, data);
 }
 
 static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu,
-        gint64 currentLimit, gfloat limit) {
+				 gint64 currentLimit, gfloat limit)
+{
     char speed[32];
     GtkWidget *item;
     gboolean active = limit < 0 ? FALSE : (currentLimit == (gint64) limit);
 
     if (limit >= 1000)
-        g_snprintf(speed, sizeof(speed), "%.2f MB/s", limit / 1024);
+	g_snprintf(speed, sizeof(speed), "%.2f MB/s", limit / 1024);
     else
-        g_snprintf(speed, sizeof(speed), "%.0f KB/s", limit);
+	g_snprintf(speed, sizeof(speed), "%.0f KB/s", limit);
 
     item = gtk_check_menu_item_new_with_label(speed);
 
     /* Yeah, I know it's unsafe to cast from a float to an int, but its safe here */
-    g_object_set_data(G_OBJECT(item), "limit", GINT_TO_POINTER((gint) limit));
+    g_object_set_data(G_OBJECT(item), "limit",
+		      GINT_TO_POINTER((gint) limit));
     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), active);
     g_signal_connect(item, "activate", G_CALLBACK(set_limit_cb), win);
 
@@ -1526,7 +1766,9 @@ static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu,
 }
 
 static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
-        gchar * enabledKey, gchar * speedKey, JsonArray * ids) {
+				 gchar * enabledKey, gchar * speedKey,
+				 JsonArray * ids)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgClient *client = priv->client;
     JsonObject *current = NULL;
@@ -1535,29 +1777,31 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
     gint64 limit;
 
     if (ids)
-        get_torrent_data(trg_client_get_torrent_table(client),
-                priv->selectedTorrentId, &current, &iter);
+	get_torrent_data(trg_client_get_torrent_table(client),
+			 priv->selectedTorrentId, &current, &iter);
     else
-        current = trg_client_get_session(client);
+	current = trg_client_get_session(client);
 
     limit
-            = json_object_get_boolean_member(current, enabledKey) ? json_object_get_int_member(
-                    current, speedKey)
-                    : -1;
+	=
+	json_object_get_boolean_member(current,
+				       enabledKey) ?
+	json_object_get_int_member(current, speedKey)
+	: -1;
     toplevel = gtk_image_menu_item_new_with_label(GTK_STOCK_NETWORK);
     gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(toplevel), TRUE);
     gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM
-    (toplevel), TRUE);
+					      (toplevel), TRUE);
     gtk_menu_item_set_label(GTK_MENU_ITEM(toplevel), title);
 
     menu = gtk_menu_new();
 
     g_object_set_data_full(G_OBJECT(menu), "speedKey", g_strdup(speedKey),
-            g_free);
-    g_object_set_data_full(G_OBJECT(menu), "enabledKey", g_strdup(enabledKey),
-            g_free);
+			   g_free);
+    g_object_set_data_full(G_OBJECT(menu), "enabledKey",
+			   g_strdup(enabledKey), g_free);
     g_object_set_data_full(G_OBJECT(menu), "limit-ids", ids,
-            (GDestroyNotify) json_array_unref);
+			   (GDestroyNotify) json_array_unref);
 
     item = gtk_check_menu_item_new_with_label(_("No Limit"));
     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), limit < 0);
@@ -1565,7 +1809,8 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
     g_signal_connect(item, "activate", G_CALLBACK(set_limit_cb), win);
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			  gtk_separator_menu_item_new());
 
     limit_item_new(win, menu, limit, 0);
     limit_item_new(win, menu, limit, 5);
@@ -1592,54 +1837,58 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
     return toplevel;
 }
 
-static void exec_cmd_cb(GtkWidget *w, gpointer data) {
+static void exec_cmd_cb(GtkWidget * w, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
-    JsonObject *cmd_obj = (JsonObject*) g_object_get_data(G_OBJECT(w),
-            "cmd-object");
-    GtkTreeSelection *selection = gtk_tree_view_get_selection(
-            GTK_TREE_VIEW(priv->torrentTreeView));
+    JsonObject *cmd_obj = (JsonObject *) g_object_get_data(G_OBJECT(w),
+							   "cmd-object");
+    GtkTreeSelection *selection =
+	gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->torrentTreeView));
     GtkTreeModel *model;
-    GList *selectedRows = gtk_tree_selection_get_selected_rows(selection, &model);
+    GList *selectedRows =
+	gtk_tree_selection_get_selected_rows(selection, &model);
     GError *cmd_error = NULL;
     gchar *cmd_line, **argv;
 
-    cmd_line = build_remote_exec_cmd(
-            priv->client,
-            model,
-            selectedRows,
-            json_object_get_string_member(cmd_obj,
-                    TRG_PREFS_KEY_EXEC_COMMANDS_SUBKEY_CMD));
+    cmd_line = build_remote_exec_cmd(priv->client,
+				     model,
+				     selectedRows,
+				     json_object_get_string_member(cmd_obj,
+								   TRG_PREFS_KEY_EXEC_COMMANDS_SUBKEY_CMD));
 
-    g_debug("Exec: %s",cmd_line);
+    g_debug("Exec: %s", cmd_line);
 
     if (!cmd_line)
-        return;
+	return;
 
     //GTK has bug, won't let you pass a string here containing a quoted param, so use parse and then spawn
     // rather than g_spawn_command_line_async(cmd_line,&cmd_error);
 
     g_shell_parse_argv(cmd_line, NULL, &argv, NULL);
     g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL,
-            &cmd_error);
+		  &cmd_error);
 
-    g_list_foreach (selectedRows, (GFunc) gtk_tree_path_free, NULL);
+    g_list_foreach(selectedRows, (GFunc) gtk_tree_path_free, NULL);
     g_list_free(selectedRows);
     g_strfreev(argv);
     g_free(cmd_line);
 
     if (cmd_error) {
-        GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(data),
-                GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s",
-                cmd_error->message);
-        gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
-        gtk_dialog_run(GTK_DIALOG(dialog));
-        gtk_widget_destroy(dialog);
-        g_error_free(cmd_error);
+	GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(data),
+						   GTK_DIALOG_MODAL,
+						   GTK_MESSAGE_ERROR,
+						   GTK_BUTTONS_OK, "%s",
+						   cmd_error->message);
+	gtk_window_set_title(GTK_WINDOW(dialog), _("Error"));
+	gtk_dialog_run(GTK_DIALOG(dialog));
+	gtk_widget_destroy(dialog);
+	g_error_free(cmd_error);
     }
 }
 
 static void trg_torrent_tv_view_menu(GtkWidget * treeview,
-        GdkEventButton * event, gpointer data) {
+				     GdkEventButton * event, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     GtkWidget *menu;
@@ -1651,145 +1900,202 @@ static void trg_torrent_tv_view_menu(GtkWidget * treeview,
     ids = build_json_id_array(TRG_TORRENT_TREE_VIEW(treeview));
 
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Properties"),
-            GTK_STOCK_PROPERTIES, TRUE, G_CALLBACK(open_props_cb), data);
+			  GTK_STOCK_PROPERTIES, TRUE,
+			  G_CALLBACK(open_props_cb), data);
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume"),
-            GTK_STOCK_MEDIA_PLAY, TRUE, G_CALLBACK(resume_cb), data);
+			  GTK_STOCK_MEDIA_PLAY, TRUE,
+			  G_CALLBACK(resume_cb), data);
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause"),
-            GTK_STOCK_MEDIA_PAUSE, TRUE, G_CALLBACK(pause_cb), data);
-    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Verify"), GTK_STOCK_REFRESH,
-            TRUE, G_CALLBACK(verify_cb), data);
+			  GTK_STOCK_MEDIA_PAUSE, TRUE,
+			  G_CALLBACK(pause_cb), data);
+    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Verify"),
+			  GTK_STOCK_REFRESH, TRUE, G_CALLBACK(verify_cb),
+			  data);
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Re-announce"),
-            GTK_STOCK_REFRESH, TRUE, G_CALLBACK(reannounce_cb), data);
-    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move"), GTK_STOCK_HARDDISK,
-            TRUE, G_CALLBACK(move_cb), data);
-    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove"), GTK_STOCK_REMOVE,
-            TRUE, G_CALLBACK(remove_cb), data);
+			  GTK_STOCK_REFRESH, TRUE,
+			  G_CALLBACK(reannounce_cb), data);
+    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move"),
+			  GTK_STOCK_HARDDISK, TRUE, G_CALLBACK(move_cb),
+			  data);
+    trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove"),
+			  GTK_STOCK_REMOVE, TRUE, G_CALLBACK(remove_cb),
+			  data);
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Remove & Delete"),
-            GTK_STOCK_CLEAR, TRUE, G_CALLBACK(delete_cb), data);
+			  GTK_STOCK_CLEAR, TRUE, G_CALLBACK(delete_cb),
+			  data);
 
-    cmds = trg_prefs_get_array(prefs, TRG_PREFS_KEY_EXEC_COMMANDS, TRG_PREFS_CONNECTION);
+    cmds =
+	trg_prefs_get_array(prefs, TRG_PREFS_KEY_EXEC_COMMANDS,
+			    TRG_PREFS_CONNECTION);
     n_cmds = json_array_get_length(cmds);
 
     if (n_cmds > 0) {
-        GList *cmds_list = json_array_get_elements(cmds);
-        GtkMenuShell *cmds_shell;
-        GList *cmds_li;
-
-        if (n_cmds < 3) {
-            gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
-            cmds_shell = GTK_MENU_SHELL(menu);
-        } else {
-            GtkImageMenuItem *cmds_menu = GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_with_label(GTK_STOCK_EXECUTE));
-            gtk_image_menu_item_set_use_stock(cmds_menu, TRUE);
-            gtk_image_menu_item_set_always_show_image(cmds_menu, TRUE);
-            gtk_menu_item_set_label(GTK_MENU_ITEM(cmds_menu), _("Actions"));
-
-            cmds_shell = GTK_MENU_SHELL(gtk_menu_new());
-            gtk_menu_item_set_submenu(GTK_MENU_ITEM(cmds_menu), GTK_WIDGET(cmds_shell));
-            gtk_menu_shell_append(GTK_MENU_SHELL(menu), GTK_WIDGET(cmds_menu));
-        }
-
-        for (cmds_li = cmds_list; cmds_li; cmds_li = g_list_next(cmds_li))
-        {
-            JsonObject *cmd_obj = json_node_get_object((JsonNode*)cmds_li->data);
-            const gchar *cmd_label = json_object_get_string_member(cmd_obj, "label");
-            GtkWidget *item = trg_imagemenuitem_new(cmds_shell, cmd_label,
-                    GTK_STOCK_EXECUTE, TRUE, G_CALLBACK(exec_cmd_cb), data);
-            g_object_set_data(G_OBJECT(item), "cmd-object", cmd_obj);
-        }
-
-        g_list_free(cmds_list);
+	GList *cmds_list = json_array_get_elements(cmds);
+	GtkMenuShell *cmds_shell;
+	GList *cmds_li;
+
+	if (n_cmds < 3) {
+	    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+				  gtk_separator_menu_item_new());
+	    cmds_shell = GTK_MENU_SHELL(menu);
+	} else {
+	    GtkImageMenuItem *cmds_menu =
+		GTK_IMAGE_MENU_ITEM(gtk_image_menu_item_new_with_label
+				    (GTK_STOCK_EXECUTE));
+	    gtk_image_menu_item_set_use_stock(cmds_menu, TRUE);
+	    gtk_image_menu_item_set_always_show_image(cmds_menu, TRUE);
+	    gtk_menu_item_set_label(GTK_MENU_ITEM(cmds_menu),
+				    _("Actions"));
+
+	    cmds_shell = GTK_MENU_SHELL(gtk_menu_new());
+	    gtk_menu_item_set_submenu(GTK_MENU_ITEM(cmds_menu),
+				      GTK_WIDGET(cmds_shell));
+	    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+				  GTK_WIDGET(cmds_menu));
+	}
+
+	for (cmds_li = cmds_list; cmds_li; cmds_li = g_list_next(cmds_li)) {
+	    JsonObject *cmd_obj =
+		json_node_get_object((JsonNode *) cmds_li->data);
+	    const gchar *cmd_label =
+		json_object_get_string_member(cmd_obj, "label");
+	    GtkWidget *item = trg_imagemenuitem_new(cmds_shell, cmd_label,
+						    GTK_STOCK_EXECUTE,
+						    TRUE,
+						    G_CALLBACK
+						    (exec_cmd_cb), data);
+	    g_object_set_data(G_OBJECT(item), "cmd-object", cmd_obj);
+	}
+
+	g_list_free(cmds_list);
     }
 
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			  gtk_separator_menu_item_new());
 
     if (priv->queuesEnabled) {
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Start Now"),
-                GTK_STOCK_MEDIA_PLAY, TRUE, G_CALLBACK(start_now_cb), data);
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Up Queue"),
-                GTK_STOCK_GO_UP, TRUE, G_CALLBACK(up_queue_cb), data);
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Down Queue"),
-                GTK_STOCK_GO_DOWN, TRUE, G_CALLBACK(down_queue_cb), data);
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Bottom Of Queue"),
-                GTK_STOCK_GOTO_BOTTOM, TRUE, G_CALLBACK(bottom_queue_cb), data);
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Top Of Queue"),
-                GTK_STOCK_GOTO_TOP, TRUE, G_CALLBACK(top_queue_cb), data);
-        gtk_menu_shell_append(GTK_MENU_SHELL(menu),
-                gtk_separator_menu_item_new());
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Start Now"),
+			      GTK_STOCK_MEDIA_PLAY, TRUE,
+			      G_CALLBACK(start_now_cb), data);
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Up Queue"),
+			      GTK_STOCK_GO_UP, TRUE,
+			      G_CALLBACK(up_queue_cb), data);
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Move Down Queue"),
+			      GTK_STOCK_GO_DOWN, TRUE,
+			      G_CALLBACK(down_queue_cb), data);
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Bottom Of Queue"),
+			      GTK_STOCK_GOTO_BOTTOM, TRUE,
+			      G_CALLBACK(bottom_queue_cb), data);
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Top Of Queue"),
+			      GTK_STOCK_GOTO_TOP, TRUE,
+			      G_CALLBACK(top_queue_cb), data);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			      gtk_separator_menu_item_new());
     }
 
-    gtk_menu_shell_append(
-            GTK_MENU_SHELL(menu),
-            limit_menu_new(TRG_MAIN_WINDOW(data), _("Down Limit"),
-                    FIELD_DOWNLOAD_LIMITED, FIELD_DOWNLOAD_LIMIT, ids));
-    gtk_menu_shell_append(
-            GTK_MENU_SHELL(menu),
-            limit_menu_new(TRG_MAIN_WINDOW(data), _("Up Limit"),
-                    FIELD_UPLOAD_LIMITED, FIELD_UPLOAD_LIMIT, ids));
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			  limit_menu_new(TRG_MAIN_WINDOW(data),
+					 _("Down Limit"),
+					 FIELD_DOWNLOAD_LIMITED,
+					 FIELD_DOWNLOAD_LIMIT, ids));
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			  limit_menu_new(TRG_MAIN_WINDOW(data),
+					 _("Up Limit"),
+					 FIELD_UPLOAD_LIMITED,
+					 FIELD_UPLOAD_LIMIT, ids));
 
     gtk_widget_show_all(menu);
 
     gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
-            (event != NULL) ? event->button : 0,
-            gdk_event_get_time((GdkEvent *) event));
+		   (event != NULL) ? event->button : 0,
+		   gdk_event_get_time((GdkEvent *) event));
 }
 
-static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg) {
+static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
+					  const gchar * msg)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     gboolean connected = trg_client_is_connected(priv->client);
     GtkWidget *menu, *connect;
-    
+
     menu = gtk_menu_new();
 
 #ifdef HAVE_LIBAPPINDICATOR
     if (msg) {
-      priv->appIndicatorStatusItem = gtk_menu_item_new_with_label(msg);
-      gtk_widget_set_sensitive(priv->appIndicatorStatusItem, FALSE);
-      gtk_menu_shell_append(GTK_MENU_SHELL(menu), priv->appIndicatorStatusItem);
+	priv->appIndicatorStatusItem = gtk_menu_item_new_with_label(msg);
+	gtk_widget_set_sensitive(priv->appIndicatorStatusItem, FALSE);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			      priv->appIndicatorStatusItem);
+
+	if (connected) {
+	    priv->appIndicatorDownloadingItem = gtk_menu_item_new();
+	    gtk_widget_set_visible(priv->appIndicatorDownloadingItem,
+				   FALSE);
+	    gtk_widget_set_sensitive(priv->appIndicatorDownloadingItem,
+				     FALSE);
+	    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+				  priv->appIndicatorDownloadingItem);
+
+	    priv->appIndicatorSeedingItem = gtk_menu_item_new();
+	    gtk_widget_set_visible(priv->appIndicatorSeedingItem, FALSE);
+	    gtk_widget_set_sensitive(priv->appIndicatorSeedingItem, FALSE);
+	    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+				  priv->appIndicatorSeedingItem);
+	}
+
+	priv->appIndicatorSepItem = gtk_separator_menu_item_new();
+	gtk_widget_set_sensitive(priv->appIndicatorSepItem, FALSE);
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			      priv->appIndicatorSepItem);
     }
 #endif
-    
+
     connect = gtk_image_menu_item_new_with_label(GTK_STOCK_CONNECT);
     gtk_image_menu_item_set_use_stock(GTK_IMAGE_MENU_ITEM(connect), TRUE);
-    gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(connect), TRUE);
+    gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(connect),
+					      TRUE);
     gtk_menu_item_set_label(GTK_MENU_ITEM(connect), _("Connect"));
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM(connect), trg_menu_bar_file_connect_menu_new(win, prefs));
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM(connect),
+			      trg_menu_bar_file_connect_menu_new(win,
+								 prefs));
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), connect);
 
     if (connected) {
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Disconnect"),
-                GTK_STOCK_DISCONNECT, connected, G_CALLBACK(disconnect_cb),
-                win);
-
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add"), GTK_STOCK_ADD,
-                connected, G_CALLBACK(add_cb), win);
-
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add from URL"),
-                GTK_STOCK_ADD, connected, G_CALLBACK(add_url_cb), win);
-
-        gtk_menu_shell_append(
-                GTK_MENU_SHELL(menu),
-                limit_menu_new(win, _("Down Limit"),
-                        SGET_SPEED_LIMIT_DOWN_ENABLED, SGET_SPEED_LIMIT_DOWN,
-                        NULL));
-        gtk_menu_shell_append(
-                GTK_MENU_SHELL(menu),
-                limit_menu_new(win, _("Up Limit"),
-                        SGET_SPEED_LIMIT_UP_ENABLED, SGET_SPEED_LIMIT_UP, NULL));
-
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume All"),
-                GTK_STOCK_MEDIA_PLAY, connected, G_CALLBACK(resume_all_cb),
-                win);
-
-        trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause All"),
-                GTK_STOCK_MEDIA_PAUSE, connected, G_CALLBACK(pause_all_cb),
-                win);
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Disconnect"),
+			      GTK_STOCK_DISCONNECT, connected,
+			      G_CALLBACK(disconnect_cb), win);
+
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add"),
+			      GTK_STOCK_ADD, connected, G_CALLBACK(add_cb),
+			      win);
+
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Add from URL"),
+			      GTK_STOCK_ADD, connected,
+			      G_CALLBACK(add_url_cb), win);
+
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			      limit_menu_new(win, _("Down Limit"),
+					     SGET_SPEED_LIMIT_DOWN_ENABLED,
+					     SGET_SPEED_LIMIT_DOWN, NULL));
+	gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			      limit_menu_new(win, _("Up Limit"),
+					     SGET_SPEED_LIMIT_UP_ENABLED,
+					     SGET_SPEED_LIMIT_UP, NULL));
+
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume All"),
+			      GTK_STOCK_MEDIA_PLAY, connected,
+			      G_CALLBACK(resume_all_cb), win);
+
+	trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Pause All"),
+			      GTK_STOCK_MEDIA_PAUSE, connected,
+			      G_CALLBACK(pause_all_cb), win);
     }
 
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+			  gtk_separator_menu_item_new());
     trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Quit"), GTK_STOCK_QUIT,
-            TRUE, G_CALLBACK(quit_cb), win);
+			  TRUE, G_CALLBACK(quit_cb), win);
 
     gtk_widget_show_all(menu);
 
@@ -1797,49 +2103,56 @@ static GtkMenu *trg_status_icon_view_menu(TrgMainWindow *win, const gchar *msg)
 }
 
 static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview,
-        GdkEventButton * event, gpointer userdata) {
+					     GdkEventButton * event,
+					     gpointer userdata)
+{
     GtkTreeSelection *selection;
     GtkTreePath *path;
 
     if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
-        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
 
-        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
-                (gint) event->x, (gint) event->y, &path, NULL, NULL, NULL)) {
-            if (!gtk_tree_selection_path_is_selected(selection, path)) {
-                gtk_tree_selection_unselect_all(selection);
-                gtk_tree_selection_select_path(selection, path);
-            }
+	if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
+					  (gint) event->x, (gint) event->y,
+					  &path, NULL, NULL, NULL)) {
+	    if (!gtk_tree_selection_path_is_selected(selection, path)) {
+		gtk_tree_selection_unselect_all(selection);
+		gtk_tree_selection_select_path(selection, path);
+	    }
 
-            gtk_tree_path_free(path);
+	    gtk_tree_path_free(path);
 
-            trg_torrent_tv_view_menu(treeview, event, userdata);
-            return TRUE;
-        }
+	    trg_torrent_tv_view_menu(treeview, event, userdata);
+	    return TRUE;
+	}
     }
 
     return FALSE;
 }
 
 static gboolean torrent_tv_popup_menu_cb(GtkWidget * treeview,
-        gpointer userdata) {
+					 gpointer userdata)
+{
     trg_torrent_tv_view_menu(treeview, NULL, userdata);
     return TRUE;
 }
 
 static gboolean window_state_event(GtkWidget * widget,
-        GdkEventWindowState * event, gpointer trayIcon) {
+				   GdkEventWindowState * event,
+				   gpointer trayIcon)
+{
 #ifndef HAVE_LIBAPPINDICATOR
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(widget);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
 
-    if (priv->statusIcon && event->changed_mask == GDK_WINDOW_STATE_ICONIFIED
-            && (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
-                    || event->new_window_state == (GDK_WINDOW_STATE_ICONIFIED
-                            | GDK_WINDOW_STATE_MAXIMIZED))
-            && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE,
-                    TRG_PREFS_GLOBAL)) {
-        gtk_widget_hide(GTK_WIDGET(widget));
+    if (priv->statusIcon
+	&& event->changed_mask == GDK_WINDOW_STATE_ICONIFIED
+	&& (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED
+	    || event->new_window_state ==
+	    (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED))
+	&& trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY_MINIMISE,
+			      TRG_PREFS_GLOBAL)) {
+	gtk_widget_hide(GTK_WIDGET(widget));
     }
 
     return TRUE;
@@ -1848,107 +2161,125 @@ static gboolean window_state_event(GtkWidget * widget,
 #endif
 }
 
-void trg_main_window_remove_status_icon(TrgMainWindow * win) {
+void trg_main_window_remove_status_icon(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 #ifdef HAVE_LIBAPPINDICATOR
     if (priv->appIndicator)
-        g_object_unref(G_OBJECT(priv->appIndicator));
+	g_object_unref(G_OBJECT(priv->appIndicator));
 
     priv->appIndicator = NULL;
 #else
 
     if (priv->statusIcon)
-        g_object_unref(G_OBJECT(priv->statusIcon));
+	g_object_unref(G_OBJECT(priv->statusIcon));
 
     priv->statusIcon = NULL;
 #endif
 }
 
 #ifndef TRG_NO_GRAPH
-void trg_main_window_add_graph(TrgMainWindow * win, gboolean show) {
+void trg_main_window_add_graph(TrgMainWindow * win, gboolean show)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
-    priv->graph = trg_torrent_graph_new(gtk_widget_get_style(priv->notebook));
-    priv->graphNotebookIndex = gtk_notebook_append_page(
-            GTK_NOTEBOOK(priv->notebook), GTK_WIDGET(priv->graph),
-            gtk_label_new(_("Graph")));
+    priv->graph =
+	trg_torrent_graph_new(gtk_widget_get_style(priv->notebook));
+    priv->graphNotebookIndex =
+	gtk_notebook_append_page(GTK_NOTEBOOK(priv->notebook),
+				 GTK_WIDGET(priv->graph),
+				 gtk_label_new(_("Graph")));
 
     if (show)
-        gtk_widget_show_all(priv->notebook);
+	gtk_widget_show_all(priv->notebook);
 
     trg_torrent_graph_start(priv->graph);
 }
 
-void trg_main_window_remove_graph(TrgMainWindow * win) {
+void trg_main_window_remove_graph(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
     if (priv->graphNotebookIndex >= 0) {
-        gtk_notebook_remove_page(GTK_NOTEBOOK(priv->notebook),
-                priv->graphNotebookIndex);
-        priv->graphNotebookIndex = -1;
+	gtk_notebook_remove_page(GTK_NOTEBOOK(priv->notebook),
+				 priv->graphNotebookIndex);
+	priv->graphNotebookIndex = -1;
     }
 }
 #endif
 
-void trg_main_window_add_status_icon(TrgMainWindow * win) {
+void trg_main_window_add_status_icon(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 #ifdef HAVE_LIBAPPINDICATOR
-    if (priv->appIndicator = app_indicator_new(PACKAGE_NAME, PACKAGE_NAME, APP_INDICATOR_CATEGORY_APPLICATION_STATUS)) {
-      app_indicator_set_status(priv->appIndicator, APP_INDICATOR_STATUS_ACTIVE);
-      app_indicator_set_menu(priv->appIndicator, trg_status_icon_view_menu(win, NULL));
+    if ((priv->appIndicator =
+	 app_indicator_new(PACKAGE_NAME, PACKAGE_NAME,
+			   APP_INDICATOR_CATEGORY_APPLICATION_STATUS))) {
+	app_indicator_set_status(priv->appIndicator,
+				 APP_INDICATOR_STATUS_ACTIVE);
+	app_indicator_set_menu(priv->appIndicator,
+			       trg_status_icon_view_menu(win, NULL));
     }
 #else
     if (!priv->icon)
-        return;
+	return;
 
     priv->statusIcon = gtk_status_icon_new_from_pixbuf(priv->icon);
     gtk_status_icon_set_screen(priv->statusIcon,
-            gtk_window_get_screen(GTK_WINDOW(win)));
+			       gtk_window_get_screen(GTK_WINDOW(win)));
     g_signal_connect(priv->statusIcon, "activate",
-            G_CALLBACK(status_icon_activated), win);
+		     G_CALLBACK(status_icon_activated), win);
     g_signal_connect(priv->statusIcon, "button-press-event",
-            G_CALLBACK(status_icon_button_press_event), win);
+		     G_CALLBACK(status_icon_button_press_event), win);
     g_signal_connect(priv->statusIcon, "popup-menu",
-            G_CALLBACK(trg_status_icon_popup_menu_cb), win);
+		     G_CALLBACK(trg_status_icon_popup_menu_cb), win);
 
     gtk_status_icon_set_visible(priv->statusIcon, TRUE);
 #endif
 
-    connchange_whatever_statusicon(win, trg_client_is_connected(priv->client));
+    connchange_whatever_statusicon(win,
+				   trg_client_is_connected(priv->client));
 }
 
-TrgStateSelector *trg_main_window_get_state_selector(TrgMainWindow * win) {
+TrgStateSelector *trg_main_window_get_state_selector(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     return priv->stateSelector;
 }
 
-static gboolean trg_main_window_config_event(GtkWidget *widget,
-        GdkEvent *event, gpointer user_data G_GNUC_UNUSED) {
+static gboolean trg_main_window_config_event(GtkWidget * widget,
+					     GdkEvent * event,
+					     gpointer user_data
+					     G_GNUC_UNUSED)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(widget);
     priv->width = event->configure.width;
     priv->height = event->configure.height;
     return FALSE;
 }
 
-static void trg_client_session_updated_cb(TrgClient *tc, JsonObject *session,
-        gpointer data) {
+static void trg_client_session_updated_cb(TrgClient * tc,
+					  JsonObject * session,
+					  gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     gboolean queuesEnabled;
 
     trg_status_bar_session_update(priv->statusBar, session);
 
     if (json_object_has_member(session, SGET_DOWNLOAD_QUEUE_ENABLED)) {
-        queuesEnabled = json_object_get_boolean_member(session,
-                SGET_DOWNLOAD_QUEUE_ENABLED) || json_object_get_boolean_member(
-                session, SGET_SEED_QUEUE_ENABLED);
+	queuesEnabled = json_object_get_boolean_member(session,
+						       SGET_DOWNLOAD_QUEUE_ENABLED)
+	    || json_object_get_boolean_member(session,
+					      SGET_SEED_QUEUE_ENABLED);
     } else {
-        queuesEnabled = FALSE;
+	queuesEnabled = FALSE;
     }
 
     if (priv->queuesEnabled != queuesEnabled) {
-        trg_menu_bar_set_supports_queues(priv->menuBar, queuesEnabled);
-        trg_state_selector_set_queues_enabled(priv->stateSelector,
-                queuesEnabled);
+	trg_menu_bar_set_supports_queues(priv->menuBar, queuesEnabled);
+	trg_state_selector_set_queues_enabled(priv->stateSelector,
+					      queuesEnabled);
     }
 
     priv->queuesEnabled = queuesEnabled;
@@ -1956,40 +2287,46 @@ static void trg_client_session_updated_cb(TrgClient *tc, JsonObject *session,
 
 /* Drag & Drop support */
 static GtkTargetEntry target_list[] = {
-        /* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */
-        { "text/uri-list", GTK_TARGET_OTHER_APP | GTK_TARGET_OTHER_WIDGET, 0 }
+    /* datatype (string), restrictions on DnD (GtkTargetFlags), datatype (int) */
+    {"text/uri-list", GTK_TARGET_OTHER_APP | GTK_TARGET_OTHER_WIDGET, 0}
 };
-static guint n_targets = G_N_ELEMENTS (target_list);
 
-static void on_dropped_file(
-        GtkWidget *widget, GdkDragContext *context, gint x, gint y, 
-        GtkSelectionData *data, guint info, guint time, gpointer user_data) {
+static guint n_targets = G_N_ELEMENTS(target_list);
+
+static void on_dropped_file(GtkWidget * widget, GdkDragContext * context,
+			    gint x, gint y, GtkSelectionData * data,
+			    guint info, guint time, gpointer user_data)
+{
     TrgMainWindow *win = user_data;
 
-    if ((gtk_selection_data_get_length(data) >= 0) && (gtk_selection_data_get_format(data) == 8))
-    {
-        if (gdk_drag_context_get_actions(context) == GDK_ACTION_MOVE) {
-            g_debug ("GDK_ACTION_MOVE");
-            gchar **uri_list = gtk_selection_data_get_uris(data);
-            guint num_files = g_strv_length(uri_list);
-            gchar **file_list = g_new0(gchar *,num_files+1);
-            int i;
-            for (i = 0; i < num_files; i++) {
-                file_list[i] = g_filename_from_uri( uri_list[i], NULL, NULL );
-                g_debug ("to be added: %s",file_list[i]);
-            }
-            g_strfreev(uri_list);
-            gtk_drag_finish (context, TRUE, FALSE, time);
-            trg_add_from_filename(win,file_list);
-            return;
-        }
+    if ((gtk_selection_data_get_length(data) >= 0)
+	&& (gtk_selection_data_get_format(data) == 8)) {
+	if (gdk_drag_context_get_actions(context) == GDK_ACTION_MOVE) {
+	    g_debug("GDK_ACTION_MOVE");
+	    gchar **uri_list = gtk_selection_data_get_uris(data);
+	    guint num_files = g_strv_length(uri_list);
+	    gchar **file_list = g_new0(gchar *, num_files + 1);
+	    int i;
+	    for (i = 0; i < num_files; i++) {
+		file_list[i] =
+		    g_filename_from_uri(uri_list[i], NULL, NULL);
+		g_debug("to be added: %s", file_list[i]);
+	    }
+	    g_strfreev(uri_list);
+	    gtk_drag_finish(context, TRUE, FALSE, time);
+	    trg_add_from_filename(win, file_list);
+	    return;
+	}
     }
-    gtk_drag_finish (context, FALSE, FALSE, time);
+    gtk_drag_finish(context, FALSE, FALSE, time);
 }
 
 
 static GObject *trg_main_window_constructor(GType type,
-        guint n_construct_properties, GObjectConstructParam * construct_params) {
+					    guint n_construct_properties,
+					    GObjectConstructParam *
+					    construct_params)
+{
     TrgMainWindow *self;
     TrgMainWindowPrivate *priv;
     GtkWidget *w;
@@ -2001,9 +2338,9 @@ static GObject *trg_main_window_constructor(GType type,
     TrgPrefs *prefs;
 
     self = TRG_MAIN_WINDOW(G_OBJECT_CLASS
-            (trg_main_window_parent_class)->constructor
-            (type, n_construct_properties,
-                    construct_params));
+			   (trg_main_window_parent_class)->constructor
+			   (type, n_construct_properties,
+			    construct_params));
     priv = TRG_MAIN_WINDOW_GET_PRIVATE(self);
 
     priv->queuesEnabled = TRUE;
@@ -2012,83 +2349,88 @@ static GObject *trg_main_window_constructor(GType type,
 
     theme = gtk_icon_theme_get_default();
     priv->icon = gtk_icon_theme_load_icon(theme, PACKAGE_NAME, 48,
-            GTK_ICON_LOOKUP_USE_BUILTIN, NULL);
+					  GTK_ICON_LOOKUP_USE_BUILTIN,
+					  NULL);
 
 #ifdef HAVE_LIBNOTIFY
     notify_init(PACKAGE_NAME);
 #endif
     if (priv->icon)
-        gtk_window_set_default_icon(priv->icon);
+	gtk_window_set_default_icon(priv->icon);
 
     gtk_window_set_title(GTK_WINDOW(self), _("Transmission Remote"));
     gtk_window_set_default_size(GTK_WINDOW(self), 1000, 600);
 
     g_signal_connect(G_OBJECT(self), "delete-event",
-            G_CALLBACK(delete_event), NULL);
+		     G_CALLBACK(delete_event), NULL);
     g_signal_connect(G_OBJECT(self), "destroy", G_CALLBACK(destroy_window),
-            NULL);
+		     NULL);
     g_signal_connect(G_OBJECT(self), "window-state-event",
-            G_CALLBACK(window_state_event), NULL);
+		     G_CALLBACK(window_state_event), NULL);
     g_signal_connect(G_OBJECT(self), "configure-event",
-            G_CALLBACK(trg_main_window_config_event), NULL);
+		     G_CALLBACK(trg_main_window_config_event), NULL);
 
     priv->torrentModel = trg_torrent_model_new();
     trg_client_set_torrent_table(priv->client,
-            get_torrent_table(priv->torrentModel));
+				 get_torrent_table(priv->torrentModel));
 
     g_signal_connect(priv->torrentModel, "torrent-completed",
-            G_CALLBACK(on_torrent_completed), self);
+		     G_CALLBACK(on_torrent_completed), self);
     g_signal_connect(priv->torrentModel, "torrent-added",
-            G_CALLBACK(on_torrent_added), self);
+		     G_CALLBACK(on_torrent_added), self);
     g_signal_connect(priv->torrentModel, "update-filters",
-            G_CALLBACK(on_update_filters), self);
+		     G_CALLBACK(on_update_filters), self);
 
-    priv->sortedTorrentModel = gtk_tree_model_sort_new_with_model(
-            GTK_TREE_MODEL(priv->torrentModel));
+    priv->sortedTorrentModel =
+	gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL
+					   (priv->torrentModel));
 
-    priv->filteredTorrentModel = trg_sortable_filtered_model_new(
-            GTK_TREE_SORTABLE(priv->sortedTorrentModel), NULL);
+    priv->filteredTorrentModel =
+	trg_sortable_filtered_model_new(GTK_TREE_SORTABLE
+					(priv->sortedTorrentModel), NULL);
     gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER
-    (priv->filteredTorrentModel), trg_torrent_tree_view_visible_func,
-            self, NULL);
+					   (priv->filteredTorrentModel),
+					   trg_torrent_tree_view_visible_func,
+					   self, NULL);
 
     priv->torrentTreeView = trg_main_window_torrent_tree_view_new(self,
-            priv->filteredTorrentModel);
+								  priv->
+								  filteredTorrentModel);
     g_signal_connect(priv->torrentTreeView, "key-press-event",
-            G_CALLBACK(torrent_tv_key_press_event), self);
+		     G_CALLBACK(torrent_tv_key_press_event), self);
     g_signal_connect(priv->torrentTreeView, "popup-menu",
-            G_CALLBACK(torrent_tv_popup_menu_cb), self);
+		     G_CALLBACK(torrent_tv_popup_menu_cb), self);
     g_signal_connect(priv->torrentTreeView, "button-press-event",
-            G_CALLBACK(torrent_tv_button_pressed_cb), self);
+		     G_CALLBACK(torrent_tv_button_pressed_cb), self);
     g_signal_connect(priv->torrentTreeView, "row-activated",
-            G_CALLBACK(torrent_tv_onRowActivated), self);
+		     G_CALLBACK(torrent_tv_onRowActivated), self);
 
     outerVbox = gtk_vbox_new(FALSE, 0);
     gtk_container_add(GTK_CONTAINER(self), outerVbox);
 
     priv->menuBar = trg_main_window_menu_bar_new(self);
-    gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->menuBar), FALSE,
-            FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->menuBar),
+		       FALSE, FALSE, 0);
 
     toolbarHbox = gtk_hbox_new(FALSE, 0);
     priv->toolBar = trg_main_window_toolbar_new(self);
-    gtk_box_pack_start(GTK_BOX(toolbarHbox), GTK_WIDGET(priv->toolBar), TRUE,
-            TRUE, 0);
+    gtk_box_pack_start(GTK_BOX(toolbarHbox), GTK_WIDGET(priv->toolBar),
+		       TRUE, TRUE, 0);
 
     w = gtk_entry_new();
     gtk_entry_set_icon_from_stock(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY,
-            GTK_STOCK_CLEAR);
+				  GTK_STOCK_CLEAR);
     g_signal_connect(w, "icon-release",
-            G_CALLBACK(clear_filter_entry_cb), NULL);
+		     G_CALLBACK(clear_filter_entry_cb), NULL);
     gtk_box_pack_start(GTK_BOX(toolbarHbox), w, FALSE, FALSE, 0);
     g_object_set(w, "secondary-icon-sensitive", FALSE, NULL);
     priv->filterEntry = w;
 
     g_signal_connect(G_OBJECT(priv->filterEntry), "changed",
-            G_CALLBACK(entry_filter_changed_cb), self);
+		     G_CALLBACK(entry_filter_changed_cb), self);
 
     gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(toolbarHbox), FALSE,
-            FALSE, 0);
+		       FALSE, 0);
 
     priv->vpaned = gtk_vpaned_new();
     priv->hpaned = gtk_hpaned_new();
@@ -2096,83 +2438,89 @@ static GObject *trg_main_window_constructor(GType type,
     gtk_paned_pack1(GTK_PANED(priv->vpaned), priv->hpaned, TRUE, TRUE);
 
     priv->stateSelector = trg_state_selector_new(priv->client);
-    priv->stateSelectorScroller = my_scrolledwin_new(
-            GTK_WIDGET(priv->stateSelector));
+    priv->stateSelectorScroller =
+	my_scrolledwin_new(GTK_WIDGET(priv->stateSelector));
     gtk_paned_pack1(GTK_PANED(priv->hpaned), priv->stateSelectorScroller,
-            FALSE, FALSE);
+		    FALSE, FALSE);
 
     gtk_paned_pack2(GTK_PANED(priv->hpaned), my_scrolledwin_new(GTK_WIDGET
-    (priv->torrentTreeView)), TRUE, TRUE);
+								(priv->
+								 torrentTreeView)),
+		    TRUE, TRUE);
 
     g_signal_connect(G_OBJECT(priv->stateSelector),
-            "torrent-state-changed",
-            G_CALLBACK(torrent_state_selection_changed),
-            priv->filteredTorrentModel);
+		     "torrent-state-changed",
+		     G_CALLBACK(torrent_state_selection_changed),
+		     priv->filteredTorrentModel);
 
     priv->notebook = trg_main_window_notebook_new(self);
     gtk_paned_pack2(GTK_PANED(priv->vpaned), priv->notebook, FALSE, FALSE);
 
     tray = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SYSTEM_TRAY,
-            TRG_PREFS_GLOBAL);
+			      TRG_PREFS_GLOBAL);
     if (tray)
-        trg_main_window_add_status_icon(self);
+	trg_main_window_add_status_icon(self);
     else
-        trg_main_window_remove_status_icon(self);
+	trg_main_window_remove_status_icon(self);
 
     priv->statusBar = trg_status_bar_new();
     g_signal_connect(priv->client, "session-updated",
-            G_CALLBACK(trg_client_session_updated_cb), self);
+		     G_CALLBACK(trg_client_session_updated_cb), self);
 
-    gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->statusBar), FALSE,
-            FALSE, 2);
+    gtk_box_pack_start(GTK_BOX(outerVbox), GTK_WIDGET(priv->statusBar),
+		       FALSE, FALSE, 2);
 
     width = trg_prefs_get_int(prefs, TRG_PREFS_KEY_WINDOW_WIDTH,
-            TRG_PREFS_GLOBAL);
+			      TRG_PREFS_GLOBAL);
     height = trg_prefs_get_int(prefs, TRG_PREFS_KEY_WINDOW_HEIGHT,
-            TRG_PREFS_GLOBAL);
+			       TRG_PREFS_GLOBAL);
 
     if (width > 0 && height > 0)
-        gtk_window_set_default_size(GTK_WINDOW(self), width, height);
+	gtk_window_set_default_size(GTK_WINDOW(self), width, height);
 
     gtk_widget_show_all(GTK_WIDGET(self));
 
-    trg_widget_set_visible(
-            priv->stateSelectorScroller,
-            trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_STATE_SELECTOR,
-                    TRG_PREFS_GLOBAL));
-    trg_widget_set_visible(
-            priv->notebook,
-            trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SHOW_NOTEBOOK,
-                    TRG_PREFS_GLOBAL));
-
-    pos = trg_prefs_get_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS, TRG_PREFS_GLOBAL);
+    trg_widget_set_visible(priv->stateSelectorScroller,
+			   trg_prefs_get_bool(prefs,
+					      TRG_PREFS_KEY_SHOW_STATE_SELECTOR,
+					      TRG_PREFS_GLOBAL));
+    trg_widget_set_visible(priv->notebook,
+			   trg_prefs_get_bool(prefs,
+					      TRG_PREFS_KEY_SHOW_NOTEBOOK,
+					      TRG_PREFS_GLOBAL));
+
+    pos =
+	trg_prefs_get_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS,
+			  TRG_PREFS_GLOBAL);
     if (pos > 0)
-        gtk_paned_set_position(GTK_PANED(priv->vpaned), pos);
+	gtk_paned_set_position(GTK_PANED(priv->vpaned), pos);
 
-    pos = trg_prefs_get_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS, TRG_PREFS_GLOBAL);
+    pos =
+	trg_prefs_get_int(prefs, TRG_PREFS_KEY_STATES_PANED_POS,
+			  TRG_PREFS_GLOBAL);
     if (pos > 0)
-        gtk_paned_set_position(GTK_PANED(priv->hpaned), pos);
+	gtk_paned_set_position(GTK_PANED(priv->hpaned), pos);
 
     if (tray && priv->min_on_start)
-        gtk_widget_hide(GTK_WIDGET(self));
+	gtk_widget_hide(GTK_WIDGET(self));
 
     /* Drag and Drop */
-    gtk_drag_dest_set
-        (
-                GTK_WIDGET (self),      // widget that will accept a drop
-                GTK_DEST_DEFAULT_ALL,   // default actions for dest on DnD
-                target_list,            // lists of target to support
-                n_targets,              // size of list
-                GDK_ACTION_MOVE         // what to do with data after dropped
-                // | GDK_ACTION_COPY ... seems that file managers only need ACTION_MOVE, not ACTION_COPY
-        );
+    gtk_drag_dest_set(GTK_WIDGET(self),	// widget that will accept a drop
+		      GTK_DEST_DEFAULT_ALL,	// default actions for dest on DnD
+		      target_list,	// lists of target to support
+		      n_targets,	// size of list
+		      GDK_ACTION_MOVE	// what to do with data after dropped
+		      // | GDK_ACTION_COPY ... seems that file managers only need ACTION_MOVE, not ACTION_COPY
+	);
     //g_signal_connect (priv->torrentTreeView, "drag-motion",G_CALLBACK (drag_motion_handl), NULL);
-    g_signal_connect (self, "drag-data-received",G_CALLBACK (on_dropped_file), self);
+    g_signal_connect(self, "drag-data-received",
+		     G_CALLBACK(on_dropped_file), self);
 
     return G_OBJECT(self);
 }
 
-static void trg_main_window_class_init(TrgMainWindowClass * klass) {
+static void trg_main_window_class_init(TrgMainWindowClass * klass)
+{
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     g_type_class_add_private(klass, sizeof(TrgMainWindowPrivate));
@@ -2181,52 +2529,63 @@ static void trg_main_window_class_init(TrgMainWindowClass * klass) {
     object_class->get_property = trg_main_window_get_property;
     object_class->set_property = trg_main_window_set_property;
 
-    g_object_class_install_property(
-            object_class,
-            PROP_CLIENT,
-            g_param_spec_pointer(
-                    "trg-client",
-                    "TClient",
-                    "Client",
-                    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
-                            | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK
-                            | G_PARAM_STATIC_BLURB));
-
-    g_object_class_install_property(
-            object_class,
-            PROP_MINIMISE_ON_START,
-            g_param_spec_boolean(
-                    "min-on-start",
-                    "Min On Start",
-                    "Min On Start",
-                    FALSE,
-                    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
-                            | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK
-                            | G_PARAM_STATIC_BLURB));
-}
-
-void auto_connect_if_required(TrgMainWindow * win, gchar **args) {
+    g_object_class_install_property(object_class,
+				    PROP_CLIENT,
+				    g_param_spec_pointer("trg-client",
+							 "TClient",
+							 "Client",
+							 G_PARAM_READWRITE
+							 |
+							 G_PARAM_CONSTRUCT_ONLY
+							 |
+							 G_PARAM_STATIC_NAME
+							 |
+							 G_PARAM_STATIC_NICK
+							 |
+							 G_PARAM_STATIC_BLURB));
+
+    g_object_class_install_property(object_class,
+				    PROP_MINIMISE_ON_START,
+				    g_param_spec_boolean("min-on-start",
+							 "Min On Start",
+							 "Min On Start",
+							 FALSE,
+							 G_PARAM_READWRITE
+							 |
+							 G_PARAM_CONSTRUCT_ONLY
+							 |
+							 G_PARAM_STATIC_NAME
+							 |
+							 G_PARAM_STATIC_NICK
+							 |
+							 G_PARAM_STATIC_BLURB));
+}
+
+void auto_connect_if_required(TrgMainWindow * win, gchar ** args)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     gchar *host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME,
-            TRG_PREFS_PROFILE);
+				       TRG_PREFS_PROFILE);
 
     if (host) {
-        gint len = strlen(host);
-        g_free(host);
-        if (len > 0 && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_AUTO_CONNECT,
-                TRG_PREFS_PROFILE)) {
-            priv->args = args;
-            connect_cb(NULL, win);
-            return;
-        }
+	gint len = strlen(host);
+	g_free(host);
+	if (len > 0
+	    && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_AUTO_CONNECT,
+				  TRG_PREFS_PROFILE)) {
+	    priv->args = args;
+	    connect_cb(NULL, win);
+	    return;
+	}
     }
 
     if (args)
-        g_strfreev(args);
+	g_strfreev(args);
 }
 
-TrgMainWindow *trg_main_window_new(TrgClient * tc, gboolean minonstart) {
-    return g_object_new(TRG_TYPE_MAIN_WINDOW, "trg-client", tc, "min-on-start",
-            minonstart, NULL);
+TrgMainWindow *trg_main_window_new(TrgClient * tc, gboolean minonstart)
+{
+    return g_object_new(TRG_TYPE_MAIN_WINDOW, "trg-client", tc,
+			"min-on-start", minonstart, NULL);
 }