reindent with gnu indent. add keyboard accelerators for view menu, fix toggle filter widget also connected to toggle graph cb. add Lithuanian translation thanks to Algimantas Margevičius via launchpad.

1 files changed, 905 insertions, 635 deletions

diff --git a/src/trg-main-window.c b/src/trg-main-window.c
index 8f5f25b..013fa50 100644
--- a/src/trg-main-window.c
+++ b/src/trg-main-window.c
@@ -83,24 +83,30 @@
 /* The rather large main window class, which glues everything together. */
 
 static void update_selected_torrent_notebook(TrgMainWindow * win,
-        gint mode, gint64 id);
+                                             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);
+                                           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);
+                                       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);
@@ -117,8 +123,11 @@ static void pause_all_cb(GtkWidget * w, gpointer data);
 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);
+static gint confirm_action_dialog(GtkWindow * win,
+                                  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);
@@ -132,54 +141,65 @@ 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);
+                                  GtkEntryIconPosition icon_pos,
+                                  GdkEvent * event, gpointer user_data);
 static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell,
-        const gchar * text, char *stock_id, gboolean sensitive, GCallback cb,
-        gpointer cbdata);
+                                        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);
+                                     GdkEventButton * event,
+                                     gpointer data);
 static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
-        const gchar * msg);
+                                          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);
-static gboolean is_ready_for_torrent_action(TrgMainWindow *win);
+                                         gpointer userdata);
+static gboolean is_ready_for_torrent_action(TrgMainWindow * win);
 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 +213,7 @@ struct _TrgMainWindowPrivate {
 
     TrgStatusBar *statusBar;
     GtkWidget *iconStatusItem, *iconDownloadingItem, *iconSeedingItem,
-            *iconSepItem;
+        *iconSepItem;
 #ifdef HAVE_LIBAPPINDICATOR
     AppIndicator *appIndicator;
 #else
@@ -241,7 +261,8 @@ enum {
     PROP_0, PROP_CLIENT, PROP_MINIMISE_ON_START
 };
 
-static void reset_connect_args(TrgMainWindow * win) {
+static void reset_connect_args(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     if (priv->args) {
         g_strfreev(priv->args);
@@ -249,34 +270,37 @@ static void reset_connect_args(TrgMainWindow * win) {
     }
 }
 
-static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED) {
+static void trg_main_window_init(TrgMainWindow * self G_GNUC_UNUSED)
+{
 }
 
-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)) {
+        && 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_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);
+                               TRG_TREE_VIEW(priv->peersTreeView),
+                               trg_client_get_serial(client), t, mode);
 
         if (mode == TORRENT_GET_MODE_FIRST)
             gtk_tree_view_expand_all(GTK_TREE_VIEW(priv->filesTreeView));
@@ -289,9 +313,11 @@ static void update_selected_torrent_notebook(TrgMainWindow * win, gint mode,
 }
 
 #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;
@@ -300,20 +326,20 @@ static void torrent_event_notification(TrgTorrentModel * model, gchar * icon,
     if (!trg_prefs_get_bool(prefs, prefKey, TRG_PREFS_NOFLAGS))
         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);
+        notify_notification_attach_to_status_icon(notify,
+                                                  priv->statusIcon);
 #endif
 #endif
 
@@ -326,42 +352,49 @@ static void torrent_event_notification(TrgTorrentModel * model, gchar * icon,
 }
 #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_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) {
+                             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_GLOBAL);
     trg_prefs_set_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS,
-            gtk_paned_get_position(GTK_PANED(priv->vpaned)), TRG_PREFS_GLOBAL);
+                      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);
+                      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,7 +405,8 @@ 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;
 
@@ -380,51 +414,61 @@ static void open_props_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
         return;
 
     dialog = trg_torrent_props_dialog_new(GTK_WINDOW(data),
-            priv->torrentTreeView, priv->client);
+                                          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);
 
     if (trg_client_is_connected(priv->client))
         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);
 
     if (trg_client_is_connected(priv->client))
         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);
 
     if (trg_client_is_connected(priv->client))
         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);
@@ -435,14 +479,15 @@ gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) {
         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));
     } else {
         struct add_torrent_threadfunc_args *args =
-                g_new0(struct add_torrent_threadfunc_args, 1);
+            g_new0(struct add_torrent_threadfunc_args, 1);
         args->list = filesList;
         args->cb_data = win;
         args->client = client;
@@ -452,31 +497,35 @@ gboolean trg_add_from_filename(TrgMainWindow * win, gchar ** uris) {
         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);
 
     if (trg_client_is_connected(priv->client))
         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);
 
     if (trg_client_is_connected(priv->client))
         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_client_inc_connid(priv->client);
@@ -484,7 +533,8 @@ static void disconnect_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
     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);
@@ -518,157 +568,187 @@ void connect_cb(GtkWidget * w, gpointer data) {
         }
 
         dialog = gtk_message_dialog_new(GTK_WINDOW(data),
-                GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
-                GTK_BUTTONS_OK, "%s", msg);
+                                        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);
 
     if (trg_client_is_connected(priv->client))
-        gtk_widget_show_all(GTK_WIDGET(trg_remote_prefs_dialog_get_instance(
-                        TRG_MAIN_WINDOW(data), priv->client)));
+        gtk_widget_show_all(GTK_WIDGET
+                            (trg_remote_prefs_dialog_get_instance
+                             (TRG_MAIN_WINDOW(data), priv->client)));
 }
 
-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));
+
+    if (gtk_widget_is_sensitive(GTK_WIDGET(w)))
+        trg_state_selector_set_show_dirs(priv->stateSelector,
+                                         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));
+
+    if (gtk_widget_is_sensitive(GTK_WIDGET(w)))
+        trg_state_selector_set_show_trackers(priv->stateSelector,
+                                             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_signal_connect(b_disconnect, "clicked", 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);
     g_signal_connect(b_delete, "clicked", G_CALLBACK(delete_cb), 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_signal_connect(b_local_prefs, "clicked",
+                     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);
 
     if (trg_client_is_connected(priv->client))
         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);
 
     if (is_ready_for_torrent_action(TRG_MAIN_WINDOW(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);
 
     if (is_ready_for_torrent_action(TRG_MAIN_WINDOW(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);
 
     if (priv->queuesEnabled
-            && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
-        dispatch_async(
-                priv->client,
-                torrent_queue_move_up(
-                        build_json_id_array(priv->torrentTreeView)),
-                on_generic_interactive_action, data);
+        && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
+        dispatch_async(priv->client,
+                       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);
 
     if (priv->queuesEnabled
-            && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
-        dispatch_async(
-                priv->client,
-                torrent_queue_move_top(
-                        build_json_id_array(priv->torrentTreeView)),
-                on_generic_interactive_action, data);
+        && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
+        dispatch_async(priv->client,
+                       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);
 
     if (priv->queuesEnabled
-            && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
-        dispatch_async(
-                priv->client,
-                torrent_queue_move_bottom(
-                        build_json_id_array(priv->torrentTreeView)),
-                on_generic_interactive_action, data);
+        && is_ready_for_torrent_action(TRG_MAIN_WINDOW(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);
 
     if (priv->queuesEnabled
-            && is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
-        dispatch_async(
-                priv->client,
-                torrent_queue_move_down(
-                        build_json_id_array(priv->torrentTreeView)),
-                on_generic_interactive_action, data);
+        && is_ready_for_torrent_action(TRG_MAIN_WINDOW(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) {
+static gint confirm_action_dialog(GtkWindow * win,
+                                  GtkTreeSelection * selection,
+                                  gchar * question_single,
+                                  gchar * question_multi,
+                                  gchar * action_stock)
+{
     TrgMainWindowPrivate *priv;
     gint selectCount;
     gint response;
@@ -688,51 +768,65 @@ static gint confirm_action_dialog(GtkWindow * win, GtkTreeSelection * selection,
         firstNode = g_list_first(list);
 
         gtk_tree_model_get_iter(GTK_TREE_MODEL
-        (priv->filteredTorrentModel), &firstIter, firstNode->data);
+                                (priv->filteredTorrentModel), &firstIter,
+                                firstNode->data);
         gtk_tree_model_get(GTK_TREE_MODEL(priv->filteredTorrentModel),
-                &firstIter, TORRENT_COLUMN_NAME, &name, -1);
+                           &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);
+                                                    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);
+                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
+                                                    GTK_MESSAGE_QUESTION,
+                                                    GTK_BUTTONS_NONE,
+                                                    question_multi,
+                                                    selectCount);
 
     } else {
         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 gboolean is_ready_for_torrent_action(TrgMainWindow *win) {
+static gboolean is_ready_for_torrent_action(TrgMainWindow * win)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
-    return priv->selectedTorrentId >= 0 && trg_client_is_connected(priv->client);
+    return priv->selectedTorrentId >= 0
+        && trg_client_is_connected(priv->client);
 }
 
-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);
 
     if (is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
-        gtk_widget_show_all(
-                GTK_WIDGET(trg_torrent_move_dialog_new(
-                                TRG_MAIN_WINDOW(data), priv->client, priv->torrentTreeView)));
+        gtk_widget_show_all(GTK_WIDGET
+                            (trg_torrent_move_dialog_new
+                             (TRG_MAIN_WINDOW(data), priv->client,
+                              priv->torrentTreeView)));
 }
 
-static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
+static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
     GtkTreeSelection *selection;
     JsonArray *ids;
@@ -740,67 +834,80 @@ static void remove_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data) {
     if (!is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
         return;
 
-    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)
+                              ("<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);
+                       on_generic_interactive_action, data);
     else
         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 (!is_ready_for_torrent_action(TRG_MAIN_WINDOW(data)))
         return;
 
     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)
+                              ("<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);
+                       on_generic_interactive_action, data);
     else
         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 (!gtk_widget_is_sensitive(GTK_WIDGET(w))) {
+        return;
+    } else if (gtk_check_menu_item_get_active(w)) {
         if (priv->graphNotebookIndex < 0)
             trg_main_window_add_graph(TRG_MAIN_WINDOW(win), TRUE);
     } else {
@@ -810,49 +917,59 @@ static void trg_main_window_toggle_graph_cb(GtkCheckMenuItem * w, gpointer 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();
     GtkWidget *genScrolledWin = gtk_scrolled_window_new(NULL, NULL);
 
-    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_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(genScrolledWin),
-            GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(genScrolledWin),
-            GTK_WIDGET(priv->genDetails));
+                                   GTK_POLICY_AUTOMATIC,
+                                   GTK_POLICY_AUTOMATIC);
+    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW
+                                          (genScrolledWin),
+                                          GTK_WIDGET(priv->genDetails));
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook), genScrolledWin,
-            gtk_label_new(_("General")));
+                             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))
+    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;
@@ -861,15 +978,16 @@ static GtkWidget *trg_main_window_notebook_new(TrgMainWindow * win) {
     return notebook;
 }
 
-gboolean on_session_set(gpointer data) {
+gboolean on_session_set(gpointer data)
+{
     trg_response *response = (trg_response *) data;
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
+    TrgMainWindowPrivate *priv =
+        TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
 
     if (response->status == CURLE_OK
-            || response->status == FAIL_RESPONSE_UNSUCCESSFUL
-            )
+        || response->status == FAIL_RESPONSE_UNSUCCESSFUL)
         dispatch_async(priv->client, session_get(), on_session_get,
-                response->cb_data);
+                       response->cb_data);
 
     trg_dialog_error_handler(TRG_MAIN_WINDOW(response->cb_data), response);
     trg_response_free(response);
@@ -877,10 +995,12 @@ gboolean on_session_set(gpointer data) {
     return FALSE;
 }
 
-static gboolean on_session_get(gpointer 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 *lastSession = trg_client_get_session(client);
@@ -899,15 +1019,17 @@ static gboolean on_session_get(gpointer data) {
         }
 
         if (session_get_version(newSession, &version) == 0
-                || version < TRANSMISSION_MIN_SUPPORTED) {
+            || version < TRANSMISSION_MIN_SUPPORTED) {
             gchar *msg =
-                    g_strdup_printf(
-                            _
-                            ("This application supports Transmission %.2f and later, you have %.2f."),
-                            TRANSMISSION_MIN_SUPPORTED, version);
+                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_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);
@@ -922,8 +1044,8 @@ static gboolean on_session_get(gpointer data) {
 
     if (newSession) {
         gboolean reloadAliases = lastSession
-                && g_strcmp0(session_get_download_dir(lastSession),
-                        session_get_download_dir(newSession));
+            && g_strcmp0(session_get_download_dir(lastSession),
+                         session_get_download_dir(newSession));
 
         trg_client_set_session(client, newSession);
 
@@ -933,9 +1055,10 @@ static gboolean on_session_get(gpointer data) {
 
     if (!isConnected) {
         trg_main_window_conn_changed(win, TRUE);
-        trg_trackers_tree_view_new_connection(priv->trackersTreeView, client);
+        trg_trackers_tree_view_new_connection(priv->trackersTreeView,
+                                              client);
         dispatch_async(client, torrent_get(TORRENT_GET_TAG_MODE_FULL),
-                on_torrent_get_first, win);
+                       on_torrent_get_first, win);
     }
 
     trg_response_free(response);
@@ -944,7 +1067,8 @@ static gboolean on_session_get(gpointer data) {
 }
 
 static void connchange_whatever_statusicon(TrgMainWindow * win,
-        gboolean connected) {
+                                           gboolean connected)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
     const gchar *display = connected ? _("Connected") : _("Disconnected");
 
@@ -967,7 +1091,10 @@ static void connchange_whatever_statusicon(TrgMainWindow * win,
 }
 
 static void update_whatever_statusicon(TrgMainWindow * win,
-        const gchar * speedLabel, trg_torrent_model_update_stats * stats) {
+                                       const gchar * speedLabel,
+                                       trg_torrent_model_update_stats *
+                                       stats)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(win);
 
     gtk_widget_set_visible(priv->iconSeedingItem, stats != NULL);
@@ -976,19 +1103,20 @@ static void update_whatever_statusicon(TrgMainWindow * win,
 
     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->iconSeedingItem), seedingLabel);
-        gtk_menu_item_set_label(GTK_MENU_ITEM
-        (priv->iconDownloadingItem), downloadingLabel);
+                                                  stats->down);
+        gchar *seedingLabel =
+            g_strdup_printf(_("Seeding  %d"), stats->seeding);
+        gtk_menu_item_set_label(GTK_MENU_ITEM(priv->iconSeedingItem),
+                                seedingLabel);
+        gtk_menu_item_set_label(GTK_MENU_ITEM(priv->iconDownloadingItem),
+                                downloadingLabel);
         g_free(downloadingLabel);
         g_free(seedingLabel);
     }
 
     if (priv->iconStatusItem)
         gtk_menu_item_set_label(GTK_MENU_ITEM
-        (priv->iconStatusItem), speedLabel);
+                                (priv->iconStatusItem), speedLabel);
 
 #ifndef HAVE_LIBAPPINDICATOR
     if (priv->statusIcon)
@@ -1000,10 +1128,12 @@ static void update_whatever_statusicon(TrgMainWindow * win,
  * The callback for a torrent-get response.
  */
 
-static gboolean on_torrent_get(gpointer data, int mode) {
+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);
+    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;
@@ -1018,27 +1148,35 @@ static gboolean on_torrent_get(gpointer data, int mode) {
     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,
+        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;
 
     if (response->status != CURLE_OK) {
-        gint64 max_retries = trg_prefs_get_int(prefs, TRG_PREFS_KEY_RETRIES, TRG_PREFS_CONNECTION);
+        gint64 max_retries =
+            trg_prefs_get_int(prefs, TRG_PREFS_KEY_RETRIES,
+                              TRG_PREFS_CONNECTION);
         if (trg_client_inc_failcount(client) >= 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), max_retries, msg);
-            trg_status_bar_push_connection_msg(priv->statusBar, statusBarMsg);
+            gchar *msg =
+                make_error_message(response->obj, response->status);
+            gchar *statusBarMsg =
+                g_strdup_printf(_("Request %d/%d failed: %s"),
+                                trg_client_get_failcount(client),
+                                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_update_torrents_timerfunc,
+                                                  win);
         }
         trg_client_updateunlock(client);
         trg_response_free(response);
@@ -1048,12 +1186,15 @@ static gboolean on_torrent_get(gpointer data, int mode) {
     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);
     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);
+                               trg_status_bar_get_speed_text(priv->
+                                                             statusBar),
+                               stats);
 
 #ifndef TRG_NO_GRAPH
     if (priv->graphNotebookIndex >= 0)
@@ -1062,20 +1203,24 @@ static gboolean on_torrent_get(gpointer data, int mode) {
 
     if (mode != TORRENT_GET_MODE_INTERACTION)
         priv->timerId = g_timeout_add_seconds(interval,
-                trg_update_torrents_timerfunc, win);
+                                              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) {
+static gboolean on_torrent_get_first(gpointer data)
+{
     trg_response *response = (trg_response *) data;
-    TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_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);
@@ -1086,45 +1231,49 @@ static gboolean on_torrent_get_first(gpointer data) {
     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_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);
+        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);
+            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));
@@ -1132,7 +1281,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;
@@ -1145,26 +1296,28 @@ static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model,
 
     if (criteria != 0) {
         if (criteria & FILTER_FLAG_TRACKER) {
-            gchar *text = trg_state_selector_get_selected_text(
-                    priv->stateSelector);
+            gchar *text =
+                trg_state_selector_get_selected_text(priv->stateSelector);
             JsonObject *json = NULL;
             gboolean matchesTracker;
-            gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json, -1);
+            gtk_tree_model_get(model, iter, TORRENT_COLUMN_JSON, &json,
+                               -1);
             matchesTracker = (!json
-                    || !torrent_has_tracker(
-                            json,
-                            trg_state_selector_get_url_host_regex(
-                                    priv->stateSelector), text));
+                              || !torrent_has_tracker(json,
+                                                      trg_state_selector_get_url_host_regex
+                                                      (priv->
+                                                       stateSelector),
+                                                      text));
             g_free(text);
             if (matchesTracker)
                 return FALSE;
         } else if (criteria & FILTER_FLAG_DIR) {
-            gchar *text = trg_state_selector_get_selected_text(
-                    priv->stateSelector);
+            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);
+            gtk_tree_model_get(model, iter,
+                               TORRENT_COLUMN_DOWNLOADDIR_SHORT, &dd, -1);
             cmp = g_strcmp0(text, dd);
             g_free(dd);
             g_free(text);
@@ -1197,29 +1350,34 @@ static gboolean trg_torrent_tree_view_visible_func(GtkTreeModel * model,
     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));
+                                         (priv->torrentModel));
 }
 
-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) {
@@ -1230,7 +1388,8 @@ static gboolean trg_dialog_error_handler(TrgMainWindow * win,
         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_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);
@@ -1242,7 +1401,8 @@ static gboolean trg_dialog_error_handler(TrgMainWindow * win,
 }
 
 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;
@@ -1261,9 +1421,9 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection,
     if (firstNode) {
         GtkTreeIter iter;
         if (gtk_tree_model_get_iter(priv->filteredTorrentModel, &iter,
-                (GtkTreePath *) firstNode->data)) {
+                                    (GtkTreePath *) firstNode->data)) {
             gtk_tree_model_get(priv->filteredTorrentModel, &iter,
-                    TORRENT_COLUMN_ID, &id, -1);
+                               TORRENT_COLUMN_ID, &id, -1);
         }
     }
 
@@ -1275,10 +1435,12 @@ static gboolean torrent_selection_changed(GtkTreeSelection * selection,
     return TRUE;
 }
 
-gboolean on_generic_interactive_action(gpointer 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);
+    TrgMainWindowPrivate *priv =
+        TRG_MAIN_WINDOW_GET_PRIVATE(response->cb_data);
     TrgClient *tc = priv->client;
     TrgPrefs *prefs = trg_client_get_prefs(tc);
 
@@ -1289,14 +1451,15 @@ gboolean on_generic_interactive_action(gpointer data) {
             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))
+            else if (trg_prefs_get_bool
+                     (prefs, TRG_PREFS_KEY_UPDATE_ACTIVE_ONLY,
+                      TRG_PREFS_CONNECTION))
                 id = TORRENT_GET_TAG_MODE_UPDATE;
             else
                 id = TORRENT_GET_TAG_MODE_FULL;
 
             dispatch_async(tc, torrent_get(id), on_torrent_get_interactive,
-                    win);
+                           win);
         }
     }
 
@@ -1305,7 +1468,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_tree_store_clear(GTK_TREE_STORE(priv->filesModel));
@@ -1313,31 +1477,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);
+    g_object_set(priv->filterEntry, "secondary-icon-sensitive",
+                 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;
 
@@ -1347,7 +1515,8 @@ 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) {
@@ -1368,8 +1537,10 @@ void trg_main_window_conn_changed(TrgMainWindow * win, gboolean 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:
@@ -1384,8 +1555,11 @@ static void trg_main_window_get_property(GObject * object, guint property_id,
     }
 }
 
-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:
@@ -1400,23 +1574,25 @@ static void trg_main_window_set_property(GObject * object, guint property_id,
     }
 }
 
-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,
+    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,
 #ifndef TRG_NO_GRAPH
-            *b_show_graph,
+    *b_show_graph,
 #endif
-            *b_start_now;
+    *b_start_now;
 
     TrgMenuBar *menuBar;
     GtkAccelGroup *accel_group;
@@ -1424,67 +1600,72 @@ static TrgMenuBar *trg_main_window_menu_bar_new(TrgMainWindow * win) {
     accel_group = gtk_accel_group_new();
 
     menuBar = trg_menu_bar_new(win, trg_client_get_prefs(priv->client),
-            accel_group);
+                               accel_group);
 
     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_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_signal_connect(b_disconnect, "activate", 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);
+    g_signal_connect(b_resume_all, "activate", G_CALLBACK(resume_all_cb),
+                     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);
+    g_signal_connect(b_pause_all, "activate", G_CALLBACK(pause_all_cb),
+                     win);
     g_signal_connect(b_verify, "activate", G_CALLBACK(verify_cb), win);
-    g_signal_connect(b_reannounce, "activate", G_CALLBACK(reannounce_cb), win);
+    g_signal_connect(b_reannounce, "activate", G_CALLBACK(reannounce_cb),
+                     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_signal_connect(b_local_prefs, "activate",
+                     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_signal_connect(b_tracker_filters, "toggled",
-            G_CALLBACK(main_window_toggle_filter_trackers), win);
-#ifndef TRG_NO_GRAPH
+                     G_CALLBACK(main_window_toggle_filter_dirs), win);
     g_signal_connect(b_tracker_filters, "toggled",
-            G_CALLBACK(trg_main_window_toggle_graph_cb), win);
-#endif
+                     G_CALLBACK(main_window_toggle_filter_trackers), win);
     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);
@@ -1496,7 +1677,8 @@ 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) {
+                                  gpointer data)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
 
     gtk_window_deiconify(GTK_WINDOW(data));
@@ -1504,28 +1686,34 @@ static void status_icon_activated(GtkStatusIcon * icon G_GNUC_UNUSED,
 
     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);
+        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) {
+                                              gpointer userdata)
+{
     TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(userdata);
 
-    gtk_menu_popup(priv->iconMenu, NULL, NULL, gtk_status_icon_position_menu,
-            priv->statusIcon, 0, gtk_get_current_event_time());
+    gtk_menu_popup(priv->iconMenu, NULL, NULL,
+                   gtk_status_icon_position_menu, priv->statusIcon, 0,
+                   gtk_get_current_event_time());
 
     return TRUE;
 }
 
 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) {
         TrgMainWindowPrivate *priv = TRG_MAIN_WINDOW_GET_PRIVATE(data);
         gtk_menu_popup(priv->iconMenu, NULL, NULL,
-                gtk_status_icon_position_menu, priv->statusIcon, event->button,
-                gdk_event_get_time((GdkEvent *) event));
+                       gtk_status_icon_position_menu, priv->statusIcon,
+                       event->button,
+                       gdk_event_get_time((GdkEvent *) event));
         return TRUE;
     } else {
         return FALSE;
@@ -1534,18 +1722,22 @@ static gboolean status_icon_button_press_event(GtkStatusIcon * icon,
 #endif
 
 static void clear_filter_entry_cb(GtkEntry * entry,
-        GtkEntryIconPosition icon_pos, GdkEvent * event, gpointer user_data) {
+                                  GtkEntryIconPosition icon_pos,
+                                  GdkEvent * event, gpointer user_data)
+{
     gtk_entry_set_text(entry, "");
 }
 
 static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell,
-        const gchar * text, char *stock_id, gboolean sensitive, GCallback cb,
-        gpointer cbdata) {
+                                        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);
@@ -1554,7 +1746,8 @@ static GtkWidget *trg_imagemenuitem_new(GtkMenuShell * shell,
     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);
@@ -1580,13 +1773,15 @@ static void set_limit_cb(GtkWidget * w, gpointer data) {
     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);
 }
 
 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);
@@ -1595,7 +1790,8 @@ static GtkWidget *limit_item_new(TrgMainWindow * win, GtkWidget * menu,
 
     item = gtk_check_menu_item_new_with_label(speed);
 
-    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);
 
@@ -1604,7 +1800,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;
@@ -1614,28 +1812,28 @@ static GtkWidget *limit_menu_new(TrgMainWindow * win, gchar * title,
 
     if (ids)
         get_torrent_data(trg_client_get_torrent_table(client),
-                priv->selectedTorrentId, &current, &iter);
+                         priv->selectedTorrentId, &current, &iter);
     else
         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);
@@ -1643,7 +1841,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);
@@ -1670,24 +1869,24 @@ 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));
+                                                           "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);
+                                                               &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);
 
@@ -1699,7 +1898,7 @@ static void exec_cmd_cb(GtkWidget * w, gpointer data) {
 
     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_free(selectedRows);
@@ -1708,8 +1907,10 @@ static void exec_cmd_cb(GtkWidget * w, gpointer data) {
 
     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_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);
@@ -1718,7 +1919,8 @@ static void exec_cmd_cb(GtkWidget * w, gpointer data) {
 }
 
 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;
@@ -1730,24 +1932,32 @@ 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);
+                               TRG_PREFS_CONNECTION);
     n_cmds = json_array_get_length(cmds);
 
     if (n_cmds > 0) {
@@ -1757,71 +1967,84 @@ static void trg_torrent_tv_view_menu(GtkWidget * treeview,
 
         if (n_cmds < 3) {
             gtk_menu_shell_append(GTK_MENU_SHELL(menu),
-                    gtk_separator_menu_item_new());
+                                  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(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"));
+            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));
+                                      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);
+            JsonObject *cmd_obj = json_node_get_object((JsonNode *)
+                                                       cmds_li->data);
             const gchar *cmd_label = json_object_get_string_member(cmd_obj,
-                    "label");
+                                                                   "label");
             GtkWidget *item = trg_imagemenuitem_new(cmds_shell, cmd_label,
-                    GTK_STOCK_EXECUTE, TRUE, G_CALLBACK
-                    (exec_cmd_cb), data);
+                                                    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);
+                              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);
+                              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);
+                              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);
+                              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_STOCK_GOTO_TOP, TRUE,
+                              G_CALLBACK(top_queue_cb), data);
         gtk_menu_shell_append(GTK_MENU_SHELL(menu),
-                gtk_separator_menu_item_new());
+                              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) {
+                                          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);
@@ -1834,13 +2057,15 @@ static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), priv->iconStatusItem);
 
     if (connected) {
-        priv->iconDownloadingItem = gtk_menu_item_new_with_label(
-                _("Updating..."));
+        priv->iconDownloadingItem =
+            gtk_menu_item_new_with_label(_("Updating..."));
         gtk_widget_set_visible(priv->iconDownloadingItem, FALSE);
         gtk_widget_set_sensitive(priv->iconDownloadingItem, FALSE);
-        gtk_menu_shell_append(GTK_MENU_SHELL(menu), priv->iconDownloadingItem);
+        gtk_menu_shell_append(GTK_MENU_SHELL(menu),
+                              priv->iconDownloadingItem);
 
-        priv->iconSeedingItem = gtk_menu_item_new_with_label(_("Updating..."));
+        priv->iconSeedingItem =
+            gtk_menu_item_new_with_label(_("Updating..."));
         gtk_widget_set_visible(priv->iconSeedingItem, FALSE);
         gtk_widget_set_sensitive(priv->iconSeedingItem, FALSE);
         gtk_menu_shell_append(GTK_MENU_SHELL(menu), priv->iconSeedingItem);
@@ -1853,45 +2078,48 @@ static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
     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);
+                                              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));
+                              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);
+                              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"),
+                              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_STOCK_ADD, connected,
+                              G_CALLBACK(add_url_cb), win);
 
         trg_imagemenuitem_new(GTK_MENU_SHELL(menu), _("Resume All"),
-                GTK_STOCK_MEDIA_PLAY, connected, G_CALLBACK(resume_all_cb),
-                win);
+                              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),
-                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));
+                              GTK_STOCK_MEDIA_PAUSE, connected,
+                              G_CALLBACK(pause_all_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));
     }
 
-    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);
+    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);
 
     gtk_widget_show_all(menu);
 
@@ -1899,7 +2127,9 @@ static GtkMenu *trg_status_icon_view_menu(TrgMainWindow * win,
 }
 
 static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview,
-        GdkEventButton * event, gpointer userdata) {
+                                             GdkEventButton * event,
+                                             gpointer userdata)
+{
     GtkTreeSelection *selection;
     GtkTreePath *path;
 
@@ -1907,7 +2137,8 @@ static gboolean torrent_tv_button_pressed_cb(GtkWidget * 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)) {
+                                          (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);
@@ -1924,24 +2155,27 @@ static gboolean torrent_tv_button_pressed_cb(GtkWidget * treeview,
 }
 
 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)) {
+    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));
     }
 
@@ -1951,11 +2185,12 @@ 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
@@ -1968,13 +2203,16 @@ void trg_main_window_remove_status_icon(TrgMainWindow * win) {
 }
 
 #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);
@@ -1982,27 +2220,29 @@ void trg_main_window_add_graph(TrgMainWindow * win, gboolean show) {
     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);
         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_new(PACKAGE_NAME, PACKAGE_NAME,
+                           APP_INDICATOR_CATEGORY_APPLICATION_STATUS))) {
         app_indicator_set_status(priv->appIndicator,
-                APP_INDICATOR_STATUS_ACTIVE);
+                                 APP_INDICATOR_STATUS_ACTIVE);
         app_indicator_set_menu(priv->appIndicator,
-                trg_status_icon_view_menu(win, NULL));
+                               trg_status_icon_view_menu(win, NULL));
     }
 #else
     if (!priv->icon)
@@ -2010,35 +2250,42 @@ void trg_main_window_add_status_icon(TrgMainWindow * win) {
 
     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) {
+                                             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;
 
@@ -2046,9 +2293,9 @@ static void trg_client_session_updated_cb(TrgClient * tc, JsonObject * 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);
+                                                       SGET_DOWNLOAD_QUEUE_ENABLED)
+            || json_object_get_boolean_member(session,
+                                              SGET_SEED_QUEUE_ENABLED);
     } else {
         queuesEnabled = FALSE;
     }
@@ -2056,7 +2303,7 @@ static void trg_client_session_updated_cb(TrgClient * tc, JsonObject * session,
     if (priv->queuesEnabled != queuesEnabled) {
         trg_menu_bar_set_supports_queues(priv->menuBar, queuesEnabled);
         trg_state_selector_set_queues_enabled(priv->stateSelector,
-                queuesEnabled);
+                                              queuesEnabled);
     }
 
     priv->queuesEnabled = queuesEnabled;
@@ -2065,27 +2312,29 @@ 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 } };
+    {"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) {
+                            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)) {
+        && (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]);
-            }
+
+            for (i = 0; i < num_files; i++)
+                file_list[i] =
+                    g_filename_from_uri(uri_list[i], NULL, NULL);
+
             g_strfreev(uri_list);
             gtk_drag_finish(context, TRUE, FALSE, time);
             trg_add_from_filename(win, file_list);
@@ -2096,7 +2345,10 @@ static void on_dropped_file(GtkWidget * widget, GdkDragContext * context,
 }
 
 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;
@@ -2108,9 +2360,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;
@@ -2120,7 +2372,8 @@ static GObject *trg_main_window_constructor(GType type,
     theme = gtk_icon_theme_get_default();
     register_my_icons(theme);
     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);
@@ -2131,69 +2384,72 @@ static GObject *trg_main_window_constructor(GType type,
     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_signal_connect(G_OBJECT(self), "delete-event",
+                     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);
 
-    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, "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);
+                     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();
@@ -2201,24 +2457,27 @@ 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->torrentModel);
-    priv->stateSelectorScroller = my_scrolledwin_new(
-            GTK_WIDGET(priv->stateSelector));
-    gtk_paned_pack1(GTK_PANED(priv->hpaned), priv->stateSelectorScroller, FALSE,
-            FALSE);
+                                                 priv->torrentModel);
+    priv->stateSelectorScroller =
+        my_scrolledwin_new(GTK_WIDGET(priv->stateSelector));
+    gtk_paned_pack1(GTK_PANED(priv->hpaned), priv->stateSelectorScroller,
+                    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);
+    g_signal_connect(G_OBJECT(priv->stateSelector),
+                     "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);
     else
@@ -2226,18 +2485,18 @@ static GObject *trg_main_window_constructor(GType type,
 
     priv->statusBar = trg_status_bar_new(self, priv->client);
     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);
 
     pos = trg_prefs_get_int(prefs, TRG_PREFS_KEY_NOTEBOOK_PANED_POS,
-            TRG_PREFS_GLOBAL);
+                            TRG_PREFS_GLOBAL);
 
     if (width > 0 && height > 0)
         gtk_window_set_default_size(GTK_WINDOW(self), width, height);
@@ -2249,17 +2508,17 @@ static GObject *trg_main_window_constructor(GType type,
 
     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));
+    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_STATES_PANED_POS,
-            TRG_PREFS_GLOBAL);
+                            TRG_PREFS_GLOBAL);
     if (pos > 0)
         gtk_paned_set_position(GTK_PANED(priv->hpaned), pos);
 
@@ -2268,20 +2527,21 @@ static GObject *trg_main_window_constructor(GType type,
 
     /* 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_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));
@@ -2290,42 +2550,51 @@ 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)) {
+            && trg_prefs_get_bool(prefs, TRG_PREFS_KEY_AUTO_CONNECT,
+                                  TRG_PREFS_PROFILE)) {
             priv->args = args;
             connect_cb(NULL, win);
             return;
@@ -2336,7 +2605,8 @@ void auto_connect_if_required(TrgMainWindow * win, gchar ** 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);
 }