run GNU indent everything. not done this for a while because it was producing weird results. seems ok now.

1 files changed, 258 insertions, 189 deletions

diff --git a/src/trg-remote-prefs-dialog.c b/src/trg-remote-prefs-dialog.c
index b9a059e..6169706 100644
--- a/src/trg-remote-prefs-dialog.c
+++ b/src/trg-remote-prefs-dialog.c
@@ -41,7 +41,7 @@
  */
 
 G_DEFINE_TYPE(TrgRemotePrefsDialog, trg_remote_prefs_dialog,
-        GTK_TYPE_DIALOG)
+	      GTK_TYPE_DIALOG)
 #define TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(o) \
 (G_TYPE_INSTANCE_GET_PRIVATE ((o), TRG_TYPE_REMOTE_PREFS_DIALOG, TrgRemotePrefsDialogPrivate))
 enum {
@@ -62,9 +62,10 @@ struct _TrgRemotePrefsDialogPrivate {
 
 static GObject *instance = NULL;
 
-static void update_session(GtkDialog * dlg) {
+static void update_session(GtkDialog * dlg)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
 
     JsonNode *request = session_set();
     JsonObject *args = node_get_arguments(request);
@@ -72,16 +73,17 @@ static void update_session(GtkDialog * dlg) {
 
     /* Connection */
 
-    switch (gtk_combo_box_get_active(GTK_COMBO_BOX(priv->encryption_combo))) {
+    switch (gtk_combo_box_get_active
+	    (GTK_COMBO_BOX(priv->encryption_combo))) {
     case 0:
-        encryption = "required";
-        break;
+	encryption = "required";
+	break;
     case 2:
-        encryption = "tolerated";
-        break;
+	encryption = "tolerated";
+	break;
     default:
-        encryption = "preferred";
-        break;
+	encryption = "preferred";
+	break;
     }
 
     json_object_set_string_member(args, SGET_ENCRYPTION, encryption);
@@ -92,12 +94,13 @@ static void update_session(GtkDialog * dlg) {
 }
 
 static void trg_remote_prefs_response_cb(GtkDialog * dlg, gint res_id,
-        gpointer data G_GNUC_UNUSED) {
+					 gpointer data G_GNUC_UNUSED)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
 
     if (res_id == GTK_RESPONSE_OK)
-        update_session(dlg);
+	update_session(dlg);
 
     trg_json_widget_desc_list_free(priv->widgets);
 
@@ -106,43 +109,50 @@ static void trg_remote_prefs_response_cb(GtkDialog * dlg, gint res_id,
 }
 
 static void trg_remote_prefs_dialog_get_property(GObject * object,
-        guint property_id, GValue * value, GParamSpec * pspec) {
+						 guint property_id,
+						 GValue * value,
+						 GParamSpec * pspec)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(object);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(object);
     switch (property_id) {
     case PROP_PARENT:
-        g_value_set_object(value, priv->parent);
-        break;
+	g_value_set_object(value, priv->parent);
+	break;
     case PROP_CLIENT:
-        g_value_set_pointer(value, priv->client);
-        break;
+	g_value_set_pointer(value, priv->client);
+	break;
     default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
-        break;
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+	break;
     }
 }
 
 static void trg_remote_prefs_dialog_set_property(GObject * object,
-        guint property_id, const GValue * value, GParamSpec * pspec) {
+						 guint property_id,
+						 const GValue * value,
+						 GParamSpec * pspec)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(object);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(object);
     switch (property_id) {
     case PROP_PARENT:
-        priv->parent = g_value_get_object(value);
-        break;
+	priv->parent = g_value_get_object(value);
+	break;
     case PROP_CLIENT:
-        priv->client = g_value_get_pointer(value);
-        break;
+	priv->client = g_value_get_pointer(value);
+	break;
     default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
-        break;
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+	break;
     }
 }
 
 static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
-        JsonObject * json) {
+					JsonObject * json)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
     GtkWidget *w, *tb, *t;
     gint row = 0;
 
@@ -151,97 +161,112 @@ static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
     hig_workarea_add_section_title(t, &row, _("Bandwidth"));
 
     tb = trg_json_widget_check_new(&priv->widgets, json,
-            SGET_SPEED_LIMIT_DOWN_ENABLED, _("Limit download speed (KB/s)"),
-            NULL);
+				   SGET_SPEED_LIMIT_DOWN_ENABLED,
+				   _("Limit download speed (KB/s)"), NULL);
     w = trg_json_widget_spin_new_int(&priv->widgets, json,
-            SGET_SPEED_LIMIT_DOWN, tb, 0, INT_MAX, 1);
+				     SGET_SPEED_LIMIT_DOWN, tb, 0, INT_MAX,
+				     1);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     tb = trg_json_widget_check_new(&priv->widgets, json,
-            SGET_SPEED_LIMIT_UP_ENABLED, _("Limit upload speed (KB/s)"), NULL);
-    w = trg_json_widget_spin_new_int(&priv->widgets, json, SGET_SPEED_LIMIT_UP,
-            tb, 0, INT_MAX, 1);
+				   SGET_SPEED_LIMIT_UP_ENABLED,
+				   _("Limit upload speed (KB/s)"), NULL);
+    w = trg_json_widget_spin_new_int(&priv->widgets, json,
+				     SGET_SPEED_LIMIT_UP, tb, 0, INT_MAX,
+				     1);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     hig_workarea_add_section_title(t, &row, _("Seeding"));
 
     tb = trg_json_widget_check_new(&priv->widgets, json,
-            SGET_SEED_RATIO_LIMITED, _("Seed ratio limit"), NULL);
+				   SGET_SEED_RATIO_LIMITED,
+				   _("Seed ratio limit"), NULL);
     w = trg_json_widget_spin_new_double(&priv->widgets, json,
-            SGET_SEED_RATIO_LIMIT, tb, 0, INT_MAX, 0.1);
+					SGET_SEED_RATIO_LIMIT, tb, 0,
+					INT_MAX, 0.1);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     if (json_object_has_member(json, SGET_DOWNLOAD_QUEUE_ENABLED)) {
-        hig_workarea_add_section_title(t, &row, _("Queues"));
-
-        tb = trg_json_widget_check_new(&priv->widgets, json,
-                SGET_DOWNLOAD_QUEUE_ENABLED, _("Download queue size"), NULL);
-        w = trg_json_widget_spin_new_int(&priv->widgets, json,
-                SGET_DOWNLOAD_QUEUE_SIZE, tb, 0, INT_MAX, 1);
-        hig_workarea_add_row_w(t, &row, tb, w, NULL);
-
-        tb = trg_json_widget_check_new(&priv->widgets, json,
-                SGET_SEED_QUEUE_ENABLED, _("Seed queue size"), NULL);
-        w = trg_json_widget_spin_new_int(&priv->widgets, json,
-                SGET_SEED_QUEUE_SIZE, tb, 0, INT_MAX, 1);
-        hig_workarea_add_row_w(t, &row, tb, w, NULL);
-
-        tb
-                = trg_json_widget_check_new(&priv->widgets, json,
-                        SGET_QUEUE_STALLED_ENABLED,
-                        _("Ignore stalled (minutes)"), NULL);
-        w = trg_json_widget_spin_new_int(&priv->widgets, json,
-                SGET_QUEUE_STALLED_MINUTES, tb, 0, INT_MAX, 1);
-        hig_workarea_add_row_w(t, &row, tb, w, NULL);
+	hig_workarea_add_section_title(t, &row, _("Queues"));
+
+	tb = trg_json_widget_check_new(&priv->widgets, json,
+				       SGET_DOWNLOAD_QUEUE_ENABLED,
+				       _("Download queue size"), NULL);
+	w = trg_json_widget_spin_new_int(&priv->widgets, json,
+					 SGET_DOWNLOAD_QUEUE_SIZE, tb, 0,
+					 INT_MAX, 1);
+	hig_workarea_add_row_w(t, &row, tb, w, NULL);
+
+	tb = trg_json_widget_check_new(&priv->widgets, json,
+				       SGET_SEED_QUEUE_ENABLED,
+				       _("Seed queue size"), NULL);
+	w = trg_json_widget_spin_new_int(&priv->widgets, json,
+					 SGET_SEED_QUEUE_SIZE, tb, 0,
+					 INT_MAX, 1);
+	hig_workarea_add_row_w(t, &row, tb, w, NULL);
+
+	tb = trg_json_widget_check_new(&priv->widgets, json,
+				       SGET_QUEUE_STALLED_ENABLED,
+				       _("Ignore stalled (minutes)"),
+				       NULL);
+	w = trg_json_widget_spin_new_int(&priv->widgets, json,
+					 SGET_QUEUE_STALLED_MINUTES, tb, 0,
+					 INT_MAX, 1);
+	hig_workarea_add_row_w(t, &row, tb, w, NULL);
     }
 
     hig_workarea_add_section_title(t, &row, _("Peers"));
 
     w = trg_json_widget_spin_new_int(&priv->widgets, json,
-            SGET_PEER_LIMIT_GLOBAL, NULL, 0, INT_MAX, 5);
+				     SGET_PEER_LIMIT_GLOBAL, NULL, 0,
+				     INT_MAX, 5);
     hig_workarea_add_row(t, &row, _("Global peer limit"), w, w);
 
     w = trg_json_widget_spin_new_int(&priv->widgets, json,
-            SGET_PEER_LIMIT_PER_TORRENT, NULL, 0, INT_MAX, 5);
+				     SGET_PEER_LIMIT_PER_TORRENT, NULL, 0,
+				     INT_MAX, 5);
     hig_workarea_add_row(t, &row, _("Per torrent peer limit"), w, w);
 
     return t;
 }
 
-static gboolean on_port_tested(gpointer data) {
-    trg_response *response = (trg_response*) data;
+static gboolean on_port_tested(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
     if (TRG_IS_REMOTE_PREFS_DIALOG(response->cb_data)) {
-        TrgRemotePrefsDialogPrivate *priv =
-                TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(response->cb_data);
-
-        gtk_button_set_label(GTK_BUTTON(priv->port_test_button), _("Retest"));
-        gtk_widget_set_sensitive(priv->port_test_button, TRUE);
-
-        if (response->status == CURLE_OK) {
-            gboolean isOpen = json_object_get_boolean_member(
-                    get_arguments(response->obj), "port-is-open");
-            if (isOpen)
-                gtk_label_set_markup(
-                        GTK_LABEL(priv->port_test_label),
-                        _
-                        ("Port is <span font_weight=\"bold\" fgcolor=\"darkgreen\">open</span>"));
-            else
-                gtk_label_set_markup(
-                        GTK_LABEL(priv->port_test_label),
-                        _
-                        ("Port is <span font_weight=\"bold\" fgcolor=\"red\">closed</span>"));
-        } else {
-            trg_error_dialog(GTK_WINDOW(data), response);
-        }
+	TrgRemotePrefsDialogPrivate *priv =
+	    TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(response->cb_data);
+
+	gtk_button_set_label(GTK_BUTTON(priv->port_test_button),
+			     _("Retest"));
+	gtk_widget_set_sensitive(priv->port_test_button, TRUE);
+
+	if (response->status == CURLE_OK) {
+	    gboolean isOpen =
+		json_object_get_boolean_member(get_arguments
+					       (response->obj),
+					       "port-is-open");
+	    if (isOpen)
+		gtk_label_set_markup(GTK_LABEL(priv->port_test_label),
+				     _
+				     ("Port is <span font_weight=\"bold\" fgcolor=\"darkgreen\">open</span>"));
+	    else
+		gtk_label_set_markup(GTK_LABEL(priv->port_test_label),
+				     _
+				     ("Port is <span font_weight=\"bold\" fgcolor=\"red\">closed</span>"));
+	} else {
+	    trg_error_dialog(GTK_WINDOW(data), response);
+	}
     }
 
     trg_response_free(response);
     return FALSE;
 }
 
-static void port_test_cb(GtkButton * b, gpointer data) {
+static void port_test_cb(GtkButton * b, gpointer data)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(data);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(data);
     JsonNode *req = port_test();
 
     gtk_label_set_text(GTK_LABEL(priv->port_test_label), _("Port test"));
@@ -251,25 +276,29 @@ static void port_test_cb(GtkButton * b, gpointer data) {
     dispatch_async(priv->client, req, on_port_tested, data);
 }
 
-static gboolean on_blocklist_updated(gpointer data) {
-    trg_response *response = (trg_response*) data;
+static gboolean on_blocklist_updated(gpointer data)
+{
+    trg_response *response = (trg_response *) data;
     if (TRG_IS_REMOTE_PREFS_DIALOG(response->cb_data)) {
-        TrgRemotePrefsDialogPrivate *priv =
-                TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(response->cb_data);
-
-        gtk_widget_set_sensitive(priv->blocklist_update_button, TRUE);
-        gtk_button_set_label(GTK_BUTTON(priv->blocklist_update_button),
-                _("Update"));
-
-        if (response->status == CURLE_OK) {
-            JsonObject *args = get_arguments(response->obj);
-            gchar *labelText = g_strdup_printf(_("Blocklist (%ld entries)"),
-                    json_object_get_int_member(args, SGET_BLOCKLIST_SIZE));
-            gtk_button_set_label(GTK_BUTTON(priv->blocklist_check), labelText);
-            g_free(labelText);
-        } else {
-            trg_error_dialog(GTK_WINDOW(response->cb_data), response);
-        }
+	TrgRemotePrefsDialogPrivate *priv =
+	    TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(response->cb_data);
+
+	gtk_widget_set_sensitive(priv->blocklist_update_button, TRUE);
+	gtk_button_set_label(GTK_BUTTON(priv->blocklist_update_button),
+			     _("Update"));
+
+	if (response->status == CURLE_OK) {
+	    JsonObject *args = get_arguments(response->obj);
+	    gchar *labelText =
+		g_strdup_printf(_("Blocklist (%ld entries)"),
+				json_object_get_int_member(args,
+							   SGET_BLOCKLIST_SIZE));
+	    gtk_button_set_label(GTK_BUTTON(priv->blocklist_check),
+				 labelText);
+	    g_free(labelText);
+	} else {
+	    trg_error_dialog(GTK_WINDOW(response->cb_data), response);
+	}
     }
 
     trg_response_free(response);
@@ -277,9 +306,10 @@ static gboolean on_blocklist_updated(gpointer data) {
     return FALSE;
 }
 
-static gboolean update_blocklist_cb(GtkButton * b, gpointer data) {
+static gboolean update_blocklist_cb(GtkButton * b, gpointer data)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(data);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(data);
     JsonNode *req = blocklist_update();
 
     gtk_widget_set_sensitive(GTK_WIDGET(b), FALSE);
@@ -291,9 +321,10 @@ static gboolean update_blocklist_cb(GtkButton * b, gpointer data) {
 }
 
 static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
-        JsonObject * s) {
+				      JsonObject * s)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
 
     GtkWidget *w, *tb, *t;
     const gchar *stringValue;
@@ -302,19 +333,21 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
     t = hig_workarea_create();
 
     w = priv->encryption_combo = gtr_combo_box_new_enum(_("Required"), 0,
-            _("Preferred"), 1, _("Tolerated"), 2, NULL);
+							_("Preferred"), 1,
+							_("Tolerated"), 2,
+							NULL);
     stringValue = session_get_encryption(s);
     if (g_strcmp0(stringValue, "required") == 0) {
-        gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0);
     } else if (g_strcmp0(stringValue, "tolerated") == 0) {
-        gtk_combo_box_set_active(GTK_COMBO_BOX(w), 2);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(w), 2);
     } else {
-        gtk_combo_box_set_active(GTK_COMBO_BOX(w), 1);
+	gtk_combo_box_set_active(GTK_COMBO_BOX(w), 1);
     }
     hig_workarea_add_row(t, &row, _("Encryption"), w, NULL);
 
-    w = trg_json_widget_spin_new_int(&priv->widgets, s, SGET_PEER_PORT, NULL,
-            0, 65535, 1);
+    w = trg_json_widget_spin_new_int(&priv->widgets, s, SGET_PEER_PORT,
+				     NULL, 0, 65535, 1);
     hig_workarea_add_row(t, &row, _("Peer port"), w, w);
 
     w = priv->port_test_label = gtk_label_new(_("Port test"));
@@ -323,52 +356,57 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
     hig_workarea_add_row_w(t, &row, priv->port_test_label, w, NULL);
 
     w = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_PEER_PORT_RANDOM_ON_START, _("Random peer port on start"),
-            NULL);
+				  SGET_PEER_PORT_RANDOM_ON_START,
+				  _("Random peer port on start"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_PORT_FORWARDING_ENABLED, _("Peer port forwarding"), NULL);
+				  SGET_PORT_FORWARDING_ENABLED,
+				  _("Peer port forwarding"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = trg_json_widget_check_new(&priv->widgets, s, SGET_PEX_ENABLED,
-            _("Peer exchange (PEX)"), NULL);
+				  _("Peer exchange (PEX)"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = trg_json_widget_check_new(&priv->widgets, s, SGET_DHT_ENABLED,
-            _("Distributed Hash Table (DHT)"), NULL);
+				  _("Distributed Hash Table (DHT)"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = trg_json_widget_check_new(&priv->widgets, s, SGET_LPD_ENABLED,
-            _("Local peer discovery"), NULL);
+				  _("Local peer discovery"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     stringValue = g_strdup_printf(_("Blocklist (%ld entries)"),
-            session_get_blocklist_size(s));
-    tb = priv->blocklist_check = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_BLOCKLIST_ENABLED, stringValue, NULL);
+				  session_get_blocklist_size(s));
+    tb = priv->blocklist_check =
+	trg_json_widget_check_new(&priv->widgets, s,
+				  SGET_BLOCKLIST_ENABLED, stringValue,
+				  NULL);
     g_free((gchar *) stringValue);
 
-    w = priv->blocklist_update_button = gtk_button_new_with_label(_("Update"));
+    w = priv->blocklist_update_button =
+	gtk_button_new_with_label(_("Update"));
     g_signal_connect(G_OBJECT(w), "clicked",
-            G_CALLBACK(update_blocklist_cb), win);
+		     G_CALLBACK(update_blocklist_cb), win);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     //GtkWidget *trg_json_widget_entry_new(GList **wl, JsonObject *obj, gchar *key, GtkWidget *toggleDep);
     stringValue = session_get_blocklist_url(s);
     if (stringValue) {
-        w = trg_json_widget_entry_new(&priv->widgets, s, SGET_BLOCKLIST_URL,
-                NULL);
-        hig_workarea_add_row(t, &row, _("Blocklist URL:"), w, NULL);
+	w = trg_json_widget_entry_new(&priv->widgets, s,
+				      SGET_BLOCKLIST_URL, NULL);
+	hig_workarea_add_row(t, &row, _("Blocklist URL:"), w, NULL);
     }
 
     return t;
 }
 
 static GtkWidget *trg_rprefs_generalPage(TrgRemotePrefsDialog * win,
-        JsonObject * s) {
+					 JsonObject * s)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+	TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
 
     GtkWidget *w, *tb, *t;
     gint row = 0;
@@ -376,87 +414,104 @@ static GtkWidget *trg_rprefs_generalPage(TrgRemotePrefsDialog * win,
 
     t = hig_workarea_create();
 
-    w = trg_json_widget_entry_new(&priv->widgets, s, SGET_DOWNLOAD_DIR, NULL);
+    w = trg_json_widget_entry_new(&priv->widgets, s, SGET_DOWNLOAD_DIR,
+				  NULL);
     hig_workarea_add_row(t, &row, _("Download directory"), w, NULL);
 
     tb = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_INCOMPLETE_DIR_ENABLED, _("Incomplete download dir"), NULL);
-    w = trg_json_widget_entry_new(&priv->widgets, s, SGET_INCOMPLETE_DIR, tb);
+				   SGET_INCOMPLETE_DIR_ENABLED,
+				   _("Incomplete download dir"), NULL);
+    w = trg_json_widget_entry_new(&priv->widgets, s, SGET_INCOMPLETE_DIR,
+				  tb);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     tb = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_SCRIPT_TORRENT_DONE_ENABLED, _("Torrent done script"), NULL);
+				   SGET_SCRIPT_TORRENT_DONE_ENABLED,
+				   _("Torrent done script"), NULL);
     w = trg_json_widget_entry_new(&priv->widgets, s,
-            SGET_SCRIPT_TORRENT_DONE_FILENAME, tb);
+				  SGET_SCRIPT_TORRENT_DONE_FILENAME, tb);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     cache_size_mb = session_get_cache_size_mb(s);
     if (cache_size_mb >= 0) {
-        w = trg_json_widget_spin_new_int(&priv->widgets, s, SGET_CACHE_SIZE_MB,
-                NULL, 0, INT_MAX, 1);
-        hig_workarea_add_row(t, &row, _("Cache size (MB)"), w, w);
+	w = trg_json_widget_spin_new_int(&priv->widgets, s,
+					 SGET_CACHE_SIZE_MB, NULL, 0,
+					 INT_MAX, 1);
+	hig_workarea_add_row(t, &row, _("Cache size (MB)"), w, w);
     }
 
-    w = trg_json_widget_check_new(&priv->widgets, s, SGET_RENAME_PARTIAL_FILES,
-            _("Rename partial files"), NULL);
+    w = trg_json_widget_check_new(&priv->widgets, s,
+				  SGET_RENAME_PARTIAL_FILES,
+				  _("Rename partial files"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = trg_json_widget_check_new(&priv->widgets, s,
-            SGET_TRASH_ORIGINAL_TORRENT_FILES, _
-            ("Trash original torrent files"), NULL);
+				  SGET_TRASH_ORIGINAL_TORRENT_FILES, _
+				  ("Trash original torrent files"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
-    w = trg_json_widget_check_new(&priv->widgets, s, SGET_START_ADDED_TORRENTS,
-            _("Start added torrents"), NULL);
+    w = trg_json_widget_check_new(&priv->widgets, s,
+				  SGET_START_ADDED_TORRENTS,
+				  _("Start added torrents"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     return t;
 }
 
 static GObject *trg_remote_prefs_dialog_constructor(GType type,
-        guint n_construct_properties, GObjectConstructParam * construct_params) {
+						    guint
+						    n_construct_properties,
+						    GObjectConstructParam *
+						    construct_params)
+{
     GObject *object;
     TrgRemotePrefsDialogPrivate *priv;
     JsonObject *session;
     GtkWidget *notebook, *contentvbox;
 
     object = G_OBJECT_CLASS
-    (trg_remote_prefs_dialog_parent_class)->constructor(type,
-            n_construct_properties, construct_params);
+	(trg_remote_prefs_dialog_parent_class)->constructor(type,
+							    n_construct_properties,
+							    construct_params);
     priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(object);
     session = trg_client_get_session(priv->client);
 
     contentvbox = gtk_dialog_get_content_area(GTK_DIALOG(object));
 
     gtk_window_set_title(GTK_WINDOW(object), _("Remote Preferences"));
-    gtk_window_set_transient_for(GTK_WINDOW(object), GTK_WINDOW(priv->parent));
+    gtk_window_set_transient_for(GTK_WINDOW(object),
+				 GTK_WINDOW(priv->parent));
     gtk_window_set_destroy_with_parent(GTK_WINDOW(object), TRUE);
 
     gtk_dialog_add_button(GTK_DIALOG(object), GTK_STOCK_CLOSE,
-            GTK_RESPONSE_CLOSE);
-    gtk_dialog_add_button(GTK_DIALOG(object), GTK_STOCK_OK, GTK_RESPONSE_OK);
+			  GTK_RESPONSE_CLOSE);
+    gtk_dialog_add_button(GTK_DIALOG(object), GTK_STOCK_OK,
+			  GTK_RESPONSE_OK);
 
     gtk_container_set_border_width(GTK_CONTAINER(object), GUI_PAD);
 
     gtk_dialog_set_default_response(GTK_DIALOG(object), GTK_RESPONSE_OK);
 
     g_signal_connect(G_OBJECT(object),
-            "response",
-            G_CALLBACK(trg_remote_prefs_response_cb), NULL);
+		     "response",
+		     G_CALLBACK(trg_remote_prefs_response_cb), NULL);
 
     notebook = gtk_notebook_new();
 
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            trg_rprefs_generalPage(TRG_REMOTE_PREFS_DIALOG(object), session),
-            gtk_label_new(_("General")));
+			     trg_rprefs_generalPage(TRG_REMOTE_PREFS_DIALOG
+						    (object), session),
+			     gtk_label_new(_("General")));
 
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            trg_rprefs_connPage(TRG_REMOTE_PREFS_DIALOG(object), session),
-            gtk_label_new(_("Connections")));
+			     trg_rprefs_connPage(TRG_REMOTE_PREFS_DIALOG
+						 (object), session),
+			     gtk_label_new(_("Connections")));
 
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            trg_rprefs_limitsPage(TRG_REMOTE_PREFS_DIALOG(object), session),
-            gtk_label_new(_("Limits")));
+			     trg_rprefs_limitsPage(TRG_REMOTE_PREFS_DIALOG
+						   (object), session),
+			     gtk_label_new(_("Limits")));
 
     gtk_container_set_border_width(GTK_CONTAINER(notebook), GUI_PAD);
 
@@ -465,8 +520,9 @@ static GObject *trg_remote_prefs_dialog_constructor(GType type,
     return object;
 }
 
-static void trg_remote_prefs_dialog_class_init(
-        TrgRemotePrefsDialogClass * klass) {
+static void trg_remote_prefs_dialog_class_init(TrgRemotePrefsDialogClass *
+					       klass)
+{
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     g_type_class_add_private(klass, sizeof(TrgRemotePrefsDialogPrivate));
@@ -475,38 +531,51 @@ static void trg_remote_prefs_dialog_class_init(
     object_class->get_property = trg_remote_prefs_dialog_get_property;
     object_class->set_property = trg_remote_prefs_dialog_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_PARENT,
-            g_param_spec_object(
-                    "parent-window",
-                    "Parent window",
-                    "Parent window",
-                    TRG_TYPE_MAIN_WINDOW,
-                    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_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_PARENT,
+				    g_param_spec_object("parent-window",
+							"Parent window",
+							"Parent window",
+							TRG_TYPE_MAIN_WINDOW,
+							G_PARAM_READWRITE |
+							G_PARAM_CONSTRUCT_ONLY
+							|
+							G_PARAM_STATIC_NAME
+							|
+							G_PARAM_STATIC_NICK
+							|
+							G_PARAM_STATIC_BLURB));
 }
 
-static void trg_remote_prefs_dialog_init(TrgRemotePrefsDialog * self G_GNUC_UNUSED) {
+static void trg_remote_prefs_dialog_init(TrgRemotePrefsDialog *
+					 self G_GNUC_UNUSED)
+{
 }
 
-TrgRemotePrefsDialog *trg_remote_prefs_dialog_get_instance(
-        TrgMainWindow * parent, TrgClient * client) {
+TrgRemotePrefsDialog *trg_remote_prefs_dialog_get_instance(TrgMainWindow *
+							   parent,
+							   TrgClient *
+							   client)
+{
     if (instance == NULL) {
-        instance = g_object_new(TRG_TYPE_REMOTE_PREFS_DIALOG, "parent-window",
-                parent, "trg-client", client, NULL);
+	instance =
+	    g_object_new(TRG_TYPE_REMOTE_PREFS_DIALOG, "parent-window",
+			 parent, "trg-client", client, NULL);
     }
 
     return TRG_REMOTE_PREFS_DIALOG(instance);