some support for "alternate" speed limits, including setting them to be turned on/off at a certain time range.

1 files changed, 269 insertions, 213 deletions

diff --git a/src/trg-remote-prefs-dialog.c b/src/trg-remote-prefs-dialog.c
index 85643a0..10da428 100644
--- a/src/trg-remote-prefs-dialog.c
+++ b/src/trg-remote-prefs-dialog.c
@@ -17,6 +17,7 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+#include <math.h>
 #include <stdint.h>
 #include <glib/gi18n.h>
 #include <gtk/gtk.h>
@@ -40,8 +41,7 @@
  * as soon as the set is complete.
  */
 
-G_DEFINE_TYPE(TrgRemotePrefsDialog, trg_remote_prefs_dialog,
-              GTK_TYPE_DIALOG)
+G_DEFINE_TYPE(TrgRemotePrefsDialog, trg_remote_prefs_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 {
@@ -58,14 +58,13 @@ struct _TrgRemotePrefsDialogPrivate {
     GtkWidget *encryption_combo;
     GtkWidget *port_test_label, *port_test_button;
     GtkWidget *blocklist_update_button, *blocklist_check;
+    GtkWidget *alt_check, *alt_time_check;
 };
 
 static GObject *instance = NULL;
 
-static void update_session(GtkDialog * dlg)
-{
-    TrgRemotePrefsDialogPrivate *priv =
-        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
+static void update_session(GtkDialog * dlg) {
+    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
 
     JsonNode *request = session_set();
     JsonObject *args = node_get_arguments(request);
@@ -73,8 +72,7 @@ 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;
@@ -94,10 +92,8 @@ static void update_session(GtkDialog * dlg)
 }
 
 static void trg_remote_prefs_response_cb(GtkDialog * dlg, gint res_id,
-                                         gpointer data G_GNUC_UNUSED)
-{
-    TrgRemotePrefsDialogPrivate *priv =
-        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
+        gpointer data G_GNUC_UNUSED) {
+    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(dlg);
 
     if (res_id == GTK_RESPONSE_OK)
         update_session(dlg);
@@ -109,12 +105,9 @@ 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);
@@ -129,12 +122,9 @@ static void trg_remote_prefs_dialog_get_property(GObject * object,
 }
 
 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);
@@ -148,11 +138,105 @@ static void trg_remote_prefs_dialog_set_property(GObject * object,
     }
 }
 
-static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
-                                        JsonObject * json)
-{
+static void trg_remote_prefs_double_special_dependent(GtkWidget * widget,
+        gpointer data) {
     TrgRemotePrefsDialogPrivate *priv =
-        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+            TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(gtk_widget_get_toplevel(GTK_WIDGET(widget)));
+
+    gtk_widget_set_sensitive(
+            GTK_WIDGET(data),
+            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+            (priv->alt_time_check))
+                    || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                    (priv->alt_check)));
+}
+
+static void trg_rprefs_time_widget_savefunc(GtkWidget *w, JsonObject * obj,
+        gchar * key) {
+    GtkWidget *hourSpin = g_object_get_data(G_OBJECT(w), "hours-spin");
+    GtkWidget *minutesSpin = g_object_get_data(G_OBJECT(w), "mins-spin");
+    gdouble hoursValue = gtk_spin_button_get_value(GTK_SPIN_BUTTON(hourSpin));
+    gdouble minutesValue = gtk_spin_button_get_value(
+            GTK_SPIN_BUTTON(minutesSpin));
+
+    json_object_set_int_member(obj, key,
+            (gint64) ((hoursValue * 60.0) + minutesValue));
+
+}
+
+static gboolean on_output(GtkSpinButton *spin, gpointer data) {
+    GtkAdjustment *adj;
+    gchar *text;
+    int value;
+    adj = gtk_spin_button_get_adjustment(spin);
+    value = (int) gtk_adjustment_get_value(adj);
+    text = g_strdup_printf("%02d", value);
+    gtk_entry_set_text(GTK_ENTRY (spin), text);
+    g_free(text);
+
+    return TRUE;
+}
+
+static GtkWidget *trg_rprefs_timer_widget_spin_new(gint max,
+        GtkWidget *alt_time_check) {
+    GtkWidget *w = gtk_spin_button_new_with_range(0, max, 1);
+    gtk_widget_set_sensitive(w,
+            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(alt_time_check)));
+    g_signal_connect(G_OBJECT(alt_time_check), "toggled",
+            G_CALLBACK(toggle_active_arg_is_sensitive), w);
+    g_signal_connect(G_OBJECT(w), "output", G_CALLBACK(on_output), NULL);
+    return w;
+}
+
+static GtkWidget *trg_rprefs_time_widget_new(GList ** wl, JsonObject * obj,
+        const gchar *key, GtkWidget *alt_time_check) {
+    GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
+    GtkWidget *colonLabel = gtk_label_new(":");
+    GtkWidget *hourSpin = trg_rprefs_timer_widget_spin_new(23, alt_time_check);
+    GtkWidget *minutesSpin = trg_rprefs_timer_widget_spin_new(69,
+            alt_time_check);
+    gint64 value = json_object_get_int_member(obj, key);
+
+    trg_json_widget_desc *wd = g_new0(trg_json_widget_desc, 1);
+    wd->key = g_strdup(key);
+    wd->widget = hbox;
+    wd->saveFunc = trg_rprefs_time_widget_savefunc;
+
+    g_object_set_data(G_OBJECT(hbox), "hours-spin", hourSpin);
+    g_object_set_data(G_OBJECT(hbox), "mins-spin", minutesSpin);
+
+    gtk_spin_button_set_value(GTK_SPIN_BUTTON(hourSpin),
+            floor((gdouble) value / 60.0));
+    gtk_spin_button_set_value(GTK_SPIN_BUTTON(minutesSpin),
+            (gdouble) (value % 60));
+
+    gtk_box_pack_start(GTK_BOX(hbox), hourSpin, TRUE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), colonLabel, TRUE, FALSE, 2);
+    gtk_box_pack_start(GTK_BOX(hbox), minutesSpin, TRUE, FALSE, 0);
+
+    *wl = g_list_append(*wl, wd);
+
+    return hbox;
+}
+
+static GtkWidget *trg_rprefs_time_begin_end_new(GList ** wl, JsonObject * obj,
+        GtkWidget *alt_time_check) {
+    GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
+    GtkWidget *begin = trg_rprefs_time_widget_new(wl, obj,
+            SGET_ALT_SPEED_TIME_BEGIN, alt_time_check);
+    GtkWidget *end = trg_rprefs_time_widget_new(wl, obj,
+            SGET_ALT_SPEED_TIME_END, alt_time_check);
+
+    gtk_box_pack_start(GTK_BOX(hbox), begin, FALSE, FALSE, 0);
+    gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("-"), FALSE, FALSE, 10);
+    gtk_box_pack_start(GTK_BOX(hbox), end, FALSE, FALSE, 0);
+
+    return hbox;
+}
+
+static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
+        JsonObject * json) {
+    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
     GtkWidget *w, *tb, *t;
     gint row = 0;
 
@@ -161,99 +245,118 @@ 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);
-    w = trg_json_widget_spin_new_int(&priv->widgets, json,
-                                     SGET_SPEED_LIMIT_DOWN, tb, 0, INT_MAX,
-                                     1);
+            SGET_SPEED_LIMIT_DOWN_ENABLED, _("Limit download speed (KB/s)"),
+            NULL);
+    w = trg_json_widget_spin_new(&priv->widgets, json, SGET_SPEED_LIMIT_DOWN,
+            tb, 0, INT_MAX, 5);
     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(&priv->widgets, json, SGET_SPEED_LIMIT_UP, tb,
+            0, INT_MAX, 5);
     hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
+    w = priv->alt_check = trg_json_widget_check_new(&priv->widgets, json,
+            SGET_ALT_SPEED_ENABLED, _("Alternative speed limits enabled (now)"),
+            NULL);
+    hig_workarea_add_wide_control(t, &row, w);
+
+    tb = priv->alt_time_check = trg_json_widget_check_new(&priv->widgets, json,
+            SGET_ALT_SPEED_TIME_ENABLED, _("Alternative time range"), NULL);
+    w = trg_rprefs_time_begin_end_new(&priv->widgets, json, tb);
+    hig_workarea_add_row_w(t, &row, tb, w, NULL);
+
+    w = trg_json_widget_spin_new(&priv->widgets, json, SGET_ALT_SPEED_DOWN,
+            NULL, 0, INT_MAX, 5);
+    gtk_widget_set_sensitive(
+            w,
+            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->alt_check))
+                    || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb)));
+    g_signal_connect(G_OBJECT(tb), "toggled",
+            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+    g_signal_connect(G_OBJECT(priv->alt_check), "toggled",
+            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+    hig_workarea_add_row(t, &row, _("Down (KB/s)"), w, w);
+
+    w = trg_json_widget_spin_new(&priv->widgets, json, SGET_ALT_SPEED_UP, NULL,
+            0, INT_MAX, 5);
+    gtk_widget_set_sensitive(
+            w,
+            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->alt_check))
+                    || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tb)));
+    g_signal_connect(G_OBJECT(tb), "toggled",
+            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+    g_signal_connect(G_OBJECT(priv->alt_check), "toggled",
+            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+    hig_workarea_add_row(t, &row, _("Up (KB/s)"), w, w);
+
     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);
-    w = trg_json_widget_spin_new_double(&priv->widgets, json,
-                                        SGET_SEED_RATIO_LIMIT, tb, 0,
-                                        INT_MAX, 0.1);
+            SGET_SEED_RATIO_LIMITED, _("Seed ratio limit"), NULL);
+    w = trg_json_widget_spin_new(&priv->widgets, json, 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);
+                SGET_DOWNLOAD_QUEUE_ENABLED, _("Download queue size"), NULL);
+        w = trg_json_widget_spin_new(&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);
+                SGET_SEED_QUEUE_ENABLED, _("Seed queue size"), NULL);
+        w = trg_json_widget_spin_new(&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);
+                SGET_QUEUE_STALLED_ENABLED, _("Ignore stalled (minutes)"),
+                NULL);
+        w = trg_json_widget_spin_new(&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);
+    w = trg_json_widget_spin_new(&priv->widgets, json, 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);
+    w = trg_json_widget_spin_new(&priv->widgets, json,
+            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)
-{
+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);
+                TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(response->cb_data);
 
-        gtk_button_set_label(GTK_BUTTON(priv->port_test_button),
-                             _("Retest"));
+        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");
+            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>"));
+                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>"));
+                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);
         }
@@ -263,10 +366,9 @@ static gboolean on_port_tested(gpointer data)
     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"));
@@ -276,25 +378,21 @@ 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)
-{
+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);
+                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"));
+                _("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);
+            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);
@@ -306,10 +404,9 @@ 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);
@@ -321,10 +418,8 @@ static gboolean update_blocklist_cb(GtkButton * b, gpointer data)
 }
 
 static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
-                                      JsonObject * s)
-{
-    TrgRemotePrefsDialogPrivate *priv =
-        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+        JsonObject * s) {
+    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
 
     GtkWidget *w, *tb, *t;
     const gchar *stringValue;
@@ -333,9 +428,7 @@ 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);
@@ -346,8 +439,8 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
     }
     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(&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"));
@@ -356,46 +449,42 @@ 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"));
-    g_signal_connect(G_OBJECT(w), "clicked",
-                     G_CALLBACK(update_blocklist_cb), win);
+    w = priv->blocklist_update_button = gtk_button_new_with_label(_("Update"));
+    g_signal_connect(G_OBJECT(w), "clicked", 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);
+        w = trg_json_widget_entry_new(&priv->widgets, s, SGET_BLOCKLIST_URL,
+                NULL);
         hig_workarea_add_row(t, &row, _("Blocklist URL:"), w, NULL);
     }
 
@@ -403,10 +492,8 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
 }
 
 static GtkWidget *trg_rprefs_generalPage(TrgRemotePrefsDialog * win,
-                                         JsonObject * s)
-{
-    TrgRemotePrefsDialogPrivate *priv =
-        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+        JsonObject * s) {
+    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
 
     GtkWidget *w, *tb, *t;
     gint row = 0;
@@ -414,104 +501,86 @@ 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);
+        w = trg_json_widget_spin_new(&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);
+    g_signal_connect(G_OBJECT(object), "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);
 
@@ -520,9 +589,8 @@ 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));
@@ -531,51 +599,39 @@ static void trg_remote_prefs_dialog_class_init(TrgRemotePrefsDialogClass *
     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);