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, 290 insertions, 184 deletions

diff --git a/src/trg-remote-prefs-dialog.c b/src/trg-remote-prefs-dialog.c
index 1511ecc..8f866ea 100644
--- a/src/trg-remote-prefs-dialog.c
+++ b/src/trg-remote-prefs-dialog.c
@@ -41,7 +41,8 @@
  * 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 {
@@ -63,8 +64,10 @@ struct _TrgRemotePrefsDialogPrivate {
 
 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);
@@ -72,7 +75,8 @@ 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;
@@ -92,8 +96,10 @@ 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);
@@ -105,9 +111,12 @@ 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);
@@ -122,9 +131,12 @@ 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);
@@ -139,62 +151,76 @@ static void trg_remote_prefs_dialog_set_property(GObject * object,
 }
 
 static void trg_remote_prefs_double_special_dependent(GtkWidget * widget,
-        gpointer data) {
+                                                      gpointer data)
+{
     TrgRemotePrefsDialogPrivate *priv =
-            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)));
+        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) {
+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));
+    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));
+                               (gint64) ((hoursValue * 60.0) +
+                                         minutesValue));
 
 }
 
-static gboolean on_output(GtkSpinButton *spin, gpointer data) {
+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);
+    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 *
+                                                   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)));
+                             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_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) {
+                                             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 *hourSpin =
+        trg_rprefs_timer_widget_spin_new(23, alt_time_check);
     GtkWidget *minutesSpin = trg_rprefs_timer_widget_spin_new(69,
-            alt_time_check);
+                                                              alt_time_check);
     gint64 value = json_object_get_int_member(obj, key);
 
     trg_json_widget_desc *wd = g_new0(trg_json_widget_desc, 1);
@@ -206,9 +232,9 @@ static GtkWidget *trg_rprefs_time_widget_new(GList ** wl, JsonObject * obj,
     g_object_set_data(G_OBJECT(hbox), "mins-spin", minutesSpin);
 
     gtk_spin_button_set_value(GTK_SPIN_BUTTON(hourSpin),
-            floor((gdouble) value / 60.0));
+                              floor((gdouble) value / 60.0));
     gtk_spin_button_set_value(GTK_SPIN_BUTTON(minutesSpin),
-            (gdouble) (value % 60));
+                              (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);
@@ -219,41 +245,54 @@ static GtkWidget *trg_rprefs_time_widget_new(GList ** wl, JsonObject * obj,
     return hbox;
 }
 
-static GtkWidget *trg_rprefs_time_begin_end_new(GList ** wl, JsonObject * obj,
-        GtkWidget *alt_time_check) {
+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);
+                                                  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);
+                                                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), gtk_label_new("-"), FALSE, FALSE,
+                       10);
     gtk_box_pack_start(GTK_BOX(hbox), end, FALSE, FALSE, 0);
 
     return hbox;
 }
 
-static GtkWidget *trg_rprefs_alt_speed_spin_new(GList **wl, JsonObject *obj,
-        const gchar *key,
-        GtkWidget *alt_check, GtkWidget *alt_time_check)
+static GtkWidget *trg_rprefs_alt_speed_spin_new(GList ** wl,
+                                                JsonObject * obj,
+                                                const gchar * key,
+                                                GtkWidget * alt_check,
+                                                GtkWidget * alt_time_check)
 {
     GtkWidget *w = trg_json_widget_spin_new(wl, obj, key,
-            NULL, 0, INT_MAX, 5);
-    gtk_widget_set_sensitive(
-            w,
-            gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(alt_check))
-                    || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(alt_time_check)));
+                                            NULL, 0, INT_MAX, 5);
+    gtk_widget_set_sensitive(w,
+                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                                                          (alt_check))
+                             ||
+                             gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
+                                                          (alt_time_check)));
     g_signal_connect(G_OBJECT(alt_time_check), "toggled",
-            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+                     G_CALLBACK(trg_remote_prefs_double_special_dependent),
+                     w);
     g_signal_connect(G_OBJECT(alt_check), "toggled",
-            G_CALLBACK(trg_remote_prefs_double_special_dependent), w);
+                     G_CALLBACK(trg_remote_prefs_double_special_dependent),
+                     w);
     return w;
 }
 
 static GtkWidget *trg_rprefs_bandwidthPage(TrgRemotePrefsDialog * win,
-        JsonObject * json) {
-    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+                                           JsonObject * json)
+{
+    TrgRemotePrefsDialogPrivate *priv =
+        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
     GtkWidget *w, *tb, *t;
     gint row = 0;
 
@@ -262,44 +301,53 @@ static GtkWidget *trg_rprefs_bandwidthPage(TrgRemotePrefsDialog * win,
     hig_workarea_add_section_title(t, &row, _("Bandwidth limits"));
 
     tb = trg_json_widget_check_new(&priv->widgets, json,
-            SGET_SPEED_LIMIT_DOWN_ENABLED, _("Down Limit (KiB/s)"),
-            NULL);
-    w = trg_json_widget_spin_new(&priv->widgets, json, SGET_SPEED_LIMIT_DOWN,
-            tb, 0, INT_MAX, 5);
+                                   SGET_SPEED_LIMIT_DOWN_ENABLED,
+                                   _("Down Limit (KiB/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, _("Up Limit (KiB/s)"), NULL);
-    w = trg_json_widget_spin_new(&priv->widgets, json, SGET_SPEED_LIMIT_UP, tb,
-            0, INT_MAX, 5);
+                                   SGET_SPEED_LIMIT_UP_ENABLED,
+                                   _("Up Limit (KiB/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);
 
     hig_workarea_add_section_title(t, &row, _("Alternate limits"));
 
     w = priv->alt_check = trg_json_widget_check_new(&priv->widgets, json,
-            SGET_ALT_SPEED_ENABLED, _("Alternate speed limits active"),
-            NULL);
+                                                    SGET_ALT_SPEED_ENABLED,
+                                                    _
+                                                    ("Alternate speed limits active"),
+                                                    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, _("Alternate time range"), NULL);
+    tb = priv->alt_time_check =
+        trg_json_widget_check_new(&priv->widgets, json,
+                                  SGET_ALT_SPEED_TIME_ENABLED,
+                                  _("Alternate 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_rprefs_alt_speed_spin_new(&priv->widgets, json, SGET_ALT_SPEED_DOWN,
-            priv->alt_check, tb);
+    w = trg_rprefs_alt_speed_spin_new(&priv->widgets, json,
+                                      SGET_ALT_SPEED_DOWN, priv->alt_check,
+                                      tb);
     hig_workarea_add_row(t, &row, _("Alternate down limit (KiB/s)"), w, w);
 
-    w = trg_rprefs_alt_speed_spin_new(&priv->widgets, json, SGET_ALT_SPEED_UP,
-            priv->alt_check, tb);
+    w = trg_rprefs_alt_speed_spin_new(&priv->widgets, json,
+                                      SGET_ALT_SPEED_UP, priv->alt_check,
+                                      tb);
     hig_workarea_add_row(t, &row, _("Alternate up limit (KiB/s)"), w, w);
 
     return t;
 }
 
 static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
-        JsonObject * json) {
-    TrgRemotePrefsDialogPrivate *priv = TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
+                                        JsonObject * json)
+{
+    TrgRemotePrefsDialogPrivate *priv =
+        TRG_REMOTE_PREFS_DIALOG_GET_PRIVATE(win);
     GtkWidget *w, *tb, *t;
     gint row = 0;
 
@@ -308,69 +356,81 @@ static GtkWidget *trg_rprefs_limitsPage(TrgRemotePrefsDialog * win,
     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(&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);
+                                       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);
+                                     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(&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);
+                                       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);
+                                     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(&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(&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) {
+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);
         }
@@ -380,9 +440,10 @@ 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"));
@@ -392,21 +453,25 @@ 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);
@@ -418,9 +483,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);
@@ -432,8 +498,10 @@ 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;
@@ -443,8 +511,8 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
 
     hig_workarea_add_section_title(t, &row, _("Connections"));
 
-    w = trg_json_widget_spin_new(&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"));
@@ -453,7 +521,9 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
     hig_workarea_add_row_w(t, &row, priv->port_test_label, w, NULL);
 
     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);
@@ -466,46 +536,50 @@ static GtkWidget *trg_rprefs_connPage(TrgRemotePrefsDialog * win,
     hig_workarea_add_row(t, &row, _("Encryption"), 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);
 
     hig_workarea_add_section_title(t, &row, _("Protocol"));
 
     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);
 
     hig_workarea_add_section_title(t, &row, _("Blocklist"));
 
     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);
     }
 
@@ -513,8 +587,10 @@ 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;
@@ -524,92 +600,109 @@ static GtkWidget *trg_rprefs_generalPage(TrgRemotePrefsDialog * win,
 
     hig_workarea_add_section_title(t, &row, _("Environment"));
 
-    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(&priv->widgets, s, SGET_CACHE_SIZE_MB,
-                NULL, 0, INT_MAX, 1);
+                                     NULL, 0, INT_MAX, 1);
         hig_workarea_add_row(t, &row, _("Cache size (MiB)"), w, w);
     }
 
     hig_workarea_add_section_title(t, &row, _("Behavior"));
 
-    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_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_bandwidthPage(TRG_REMOTE_PREFS_DIALOG
-            (object), session), gtk_label_new(_("Bandwidth")));
+                             trg_rprefs_bandwidthPage
+                             (TRG_REMOTE_PREFS_DIALOG(object), session),
+                             gtk_label_new(_("Bandwidth")));
 
     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);
 
@@ -618,8 +711,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));
@@ -628,39 +722,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);