reindent

9 files changed, 365 insertions, 280 deletions

diff --git a/src/hig.c b/src/hig.c
index f5c7e5f..32432fe 100644
--- a/src/hig.c
+++ b/src/hig.c
@@ -24,7 +24,7 @@ GtkWidget *hig_workarea_create(void)
     return t;
 }
 
-void hig_workarea_add_section_divider(GtkWidget * t, guint *row)
+void hig_workarea_add_section_divider(GtkWidget * t, guint * row)
 {
     GtkWidget *w = gtk_alignment_new(0.0f, 0.0f, 0.0f, 0.0f);
 
@@ -34,7 +34,7 @@ void hig_workarea_add_section_divider(GtkWidget * t, guint *row)
 }
 
 void
-hig_workarea_add_section_title_widget(GtkWidget * t, guint *row,
+hig_workarea_add_section_title_widget(GtkWidget * t, guint * row,
                                       GtkWidget * w)
 {
     gtk_table_attach(GTK_TABLE(t), w, 0, 2, *row, *row + 1, ~0, 0, 0, 0);
@@ -43,7 +43,7 @@ hig_workarea_add_section_title_widget(GtkWidget * t, guint *row,
 
 void
 hig_workarea_add_section_title(GtkWidget * t,
-                               guint *row, const char *section_title)
+                               guint * row, const char *section_title)
 {
     char buf[512];
     GtkWidget *l;
@@ -75,7 +75,8 @@ static GtkWidget *rowNew(GtkWidget * w)
     return h;
 }
 
-void hig_workarea_add_wide_control(GtkWidget * t, guint *row, GtkWidget * w)
+void hig_workarea_add_wide_control(GtkWidget * t, guint * row,
+                                   GtkWidget * w)
 {
     GtkWidget *r = rowNew(w);
 
@@ -85,7 +86,8 @@ void hig_workarea_add_wide_control(GtkWidget * t, guint *row, GtkWidget * w)
 }
 
 void
-hig_workarea_add_wide_tall_control(GtkWidget * t, guint *row, GtkWidget * w)
+hig_workarea_add_wide_tall_control(GtkWidget * t, guint * row,
+                                   GtkWidget * w)
 {
     GtkWidget *r = rowNew(w);
 
@@ -97,7 +99,7 @@ hig_workarea_add_wide_tall_control(GtkWidget * t, guint *row, GtkWidget * w)
 }
 
 GtkWidget *hig_workarea_add_wide_checkbutton(GtkWidget * t,
-                                             guint *row,
+                                             guint * row,
                                              const char *mnemonic_string,
                                              gboolean is_active)
 {
@@ -126,7 +128,8 @@ GtkWidget *hig_workarea_add_label(GtkWidget * t, guint row,
 }
 
 static void
-hig_workarea_add_tall_control(GtkWidget * t, guint row, GtkWidget * control)
+hig_workarea_add_tall_control(GtkWidget * t, guint row,
+                              GtkWidget * control)
 {
     if (GTK_IS_MISC(control))
         gtk_misc_set_alignment(GTK_MISC(control), 0.0f, 0.5f);
@@ -137,7 +140,8 @@ hig_workarea_add_tall_control(GtkWidget * t, guint row, GtkWidget * control)
                      GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
 }
 
-void hig_workarea_add_control(GtkWidget * t, guint row, GtkWidget * control)
+void hig_workarea_add_control(GtkWidget * t, guint row,
+                              GtkWidget * control)
 {
     if (GTK_IS_MISC(control))
         gtk_misc_set_alignment(GTK_MISC(control), 0.0f, 0.5f);
@@ -149,7 +153,7 @@ void hig_workarea_add_control(GtkWidget * t, guint row, GtkWidget * control)
 
 void
 hig_workarea_add_row_w(GtkWidget * t,
-                       guint *row,
+                       guint * row,
                        GtkWidget * label,
                        GtkWidget * control, GtkWidget * mnemonic)
 {
@@ -162,7 +166,7 @@ hig_workarea_add_row_w(GtkWidget * t,
 }
 
 GtkWidget *hig_workarea_add_row(GtkWidget * t,
-                                guint *row,
+                                guint * row,
                                 const char *mnemonic_string,
                                 GtkWidget * control, GtkWidget * mnemonic)
 {
@@ -173,7 +177,7 @@ GtkWidget *hig_workarea_add_row(GtkWidget * t,
 }
 
 GtkWidget *hig_workarea_add_tall_row(GtkWidget * table,
-                                     guint *row,
+                                     guint * row,
                                      const char *mnemonic_string,
                                      GtkWidget * control,
                                      GtkWidget * mnemonic)
@@ -195,7 +199,7 @@ GtkWidget *hig_workarea_add_tall_row(GtkWidget * table,
     return l;
 }
 
-void hig_workarea_finish(GtkWidget * t, guint *row)
+void hig_workarea_finish(GtkWidget * t, guint * row)
 {
     gtk_table_resize(GTK_TABLE(t), *row, 2);
 }
diff --git a/src/torrent-cell-renderer.c b/src/torrent-cell-renderer.c
index 128473e..581459f 100644
--- a/src/torrent-cell-renderer.c
+++ b/src/torrent-cell-renderer.c
@@ -248,9 +248,11 @@ static char *getShortTransferString(TorrentCellRenderer * r,
     const gboolean haveDown = haveMeta && priv->peersToUs > 0;
 
     if (haveDown)
-        tr_formatter_speed_KBps(downStr, priv->downSpeed/speed_K, sizeof(downStr));
+        tr_formatter_speed_KBps(downStr, priv->downSpeed / speed_K,
+                                sizeof(downStr));
     if (haveUp)
-        tr_formatter_speed_KBps(upStr, priv->upSpeed/speed_K, sizeof(upStr));
+        tr_formatter_speed_KBps(upStr, priv->upSpeed / speed_K,
+                                sizeof(upStr));
 
     if (haveDown && haveUp)
         /* 1==down arrow, 2==down speed, 3==up arrow, 4==down speed */
@@ -340,7 +342,8 @@ static void getStatusString(GString * gstr, TorrentCellRenderer * r)
                                     priv->connected + priv->webSeedsToUs),
                                    priv->connected + priv->webSeedsToUs,
                                    tr_strlpercent(buf,
-                                                  priv->metadataPercentComplete,
+                                                  priv->
+                                                  metadataPercentComplete,
                                                   sizeof(buf)));
         }
     } else if (priv->flags & TORRENT_FLAG_SEEDING) {
diff --git a/src/torrent.c b/src/torrent.c
index 21da80e..b79a003 100644
--- a/src/torrent.c
+++ b/src/torrent.c
@@ -333,17 +333,17 @@ gint64 torrent_get_error(JsonObject * t)
         return json_object_get_int_member(t, FIELD_ERROR);
 }
 
-const gchar *torrent_get_creator(JsonObject *t)
+const gchar *torrent_get_creator(JsonObject * t)
 {
     return json_object_get_string_member(t, FIELD_CREATOR);
 }
 
-gint64 torrent_get_date_created(JsonObject *t)
+gint64 torrent_get_date_created(JsonObject * t)
 {
     return json_object_get_int_member(t, FIELD_DATE_CREATED);
 }
 
-const gchar *torrent_get_hash(JsonObject *t)
+const gchar *torrent_get_hash(JsonObject * t)
 {
     return json_object_get_string_member(t, FIELD_HASH_STRING);
 }
diff --git a/src/trg-main-window.c b/src/trg-main-window.c
index 036c81c..28b91a0 100644
--- a/src/trg-main-window.c
+++ b/src/trg-main-window.c
@@ -455,8 +455,7 @@ static void add_url_cb(GtkWidget * w G_GNUC_UNUSED, gpointer data)
     TrgMainWindowPrivate *priv = win->priv;
 
     TrgTorrentAddUrlDialog *dlg = trg_torrent_add_url_dialog_new(win,
-                                                                 priv->
-                                                                 client);
+                                                                 priv->client);
     gtk_widget_show_all(GTK_WIDGET(dlg));
 }
 
@@ -1417,8 +1416,7 @@ trg_torrent_tree_view_visible_func(GtkTreeModel * model,
             matchesTracker = (!json
                               || !torrent_has_tracker(json,
                                                       trg_state_selector_get_url_host_regex
-                                                      (priv->
-                                                       stateSelector),
+                                                      (priv->stateSelector),
                                                       text));
             g_free(text);
             if (matchesTracker)
@@ -2617,10 +2615,10 @@ static GObject *trg_main_window_constructor(GType type,
                                             construct_params)
 {
     TrgMainWindow *self = TRG_MAIN_WINDOW(G_OBJECT_CLASS
-                                          (trg_main_window_parent_class)->
-                                          constructor(type,
-                                                      n_construct_properties,
-                                                      construct_params));
+                                          (trg_main_window_parent_class)->constructor
+                                          (type,
+                                           n_construct_properties,
+                                           construct_params));
     TrgMainWindowPrivate *priv =
         G_TYPE_INSTANCE_GET_PRIVATE(self, TRG_TYPE_MAIN_WINDOW,
                                     TrgMainWindowPrivate);
@@ -2680,8 +2678,7 @@ static GObject *trg_main_window_constructor(GType type,
                                            self, NULL);
 
     priv->torrentTreeView = trg_main_window_torrent_tree_view_new(self,
-                                                                  priv->
-                                                                  filteredTorrentModel);
+                                                                  priv->filteredTorrentModel);
     g_signal_connect(priv->torrentTreeView, "popup-menu",
                      G_CALLBACK(torrent_tv_popup_menu_cb), self);
     g_signal_connect(priv->torrentTreeView, "button-press-event",
@@ -2735,8 +2732,7 @@ static GObject *trg_main_window_constructor(GType type,
                     FALSE, FALSE);
 
     gtk_paned_pack2(GTK_PANED(priv->hpaned), my_scrolledwin_new(GTK_WIDGET
-                                                                (priv->
-                                                                 torrentTreeView)),
+                                                                (priv->torrentTreeView)),
                     TRUE, TRUE);
 
     g_signal_connect(G_OBJECT(priv->stateSelector),
diff --git a/src/trg-menu-bar.c b/src/trg-menu-bar.c
index c701cbc..df2cad9 100644
--- a/src/trg-menu-bar.c
+++ b/src/trg-menu-bar.c
@@ -485,7 +485,8 @@ static GtkWidget *trg_menu_bar_view_menu_new(TrgMenuBar * mb)
                           priv->mb_view_transmission_compact);
     group =
         gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM
-                                      (priv->mb_view_transmission_compact));
+                                      (priv->
+                                       mb_view_transmission_compact));
     priv->mb_view_classic =
         trg_menu_bar_view_radio_item_new(priv->prefs, group,
                                          TRG_PREFS_KEY_STYLE,
@@ -495,7 +496,8 @@ static GtkWidget *trg_menu_bar_view_menu_new(TrgMenuBar * mb)
 
     gtk_menu_shell_append(GTK_MENU_SHELL(viewMenu),
                           trg_tree_view_sort_menu(TRG_TREE_VIEW
-                                                  (priv->torrent_tree_view),
+                                                  (priv->
+                                                   torrent_tree_view),
                                                   _("Sort")));
 
     priv->mb_view_states =
diff --git a/src/trg-preferences-dialog.c b/src/trg-preferences-dialog.c
index e8cfb15..ba382eb 100644
--- a/src/trg-preferences-dialog.c
+++ b/src/trg-preferences-dialog.c
@@ -384,8 +384,7 @@ trgp_double_special_dependent(GtkWidget * widget, gpointer data)
                              (priv->fullUpdateCheck)
                              &&
                              gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (priv->
-                                                           fullUpdateCheck)));
+                                                          (priv->fullUpdateCheck)));
 }
 
 static GtkWidget *trg_prefs_generalPage(TrgPreferencesDialog * dlg)
diff --git a/src/trg-remote-prefs-dialog.c b/src/trg-remote-prefs-dialog.c
index 22b29af..bb975fb 100644
--- a/src/trg-remote-prefs-dialog.c
+++ b/src/trg-remote-prefs-dialog.c
@@ -162,12 +162,10 @@ trg_remote_prefs_double_special_dependent(GtkWidget * widget,
 
     gtk_widget_set_sensitive(GTK_WIDGET(data),
                              gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (priv->
-                                                           alt_time_check))
+                                                          (priv->alt_time_check))
                              ||
                              gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
-                                                          (priv->
-                                                           alt_check)));
+                                                          (priv->alt_check)));
 }
 
 static void
diff --git a/src/trg-torrent-props-dialog.c b/src/trg-torrent-props-dialog.c
index 669f322..7c1dc15 100644
--- a/src/trg-torrent-props-dialog.c
+++ b/src/trg-torrent-props-dialog.c
@@ -52,9 +52,11 @@
  * values and then send it with the IDs.
  */
 
-G_DEFINE_TYPE(TrgTorrentPropsDialog, trg_torrent_props_dialog, GTK_TYPE_DIALOG)
+G_DEFINE_TYPE(TrgTorrentPropsDialog, trg_torrent_props_dialog,
+              GTK_TYPE_DIALOG)
 enum {
-    PROP_0, PROP_TREEVIEW, PROP_TORRENT_MODEL, PROP_PARENT_WINDOW, PROP_CLIENT
+    PROP_0, PROP_TREEVIEW, PROP_TORRENT_MODEL, PROP_PARENT_WINDOW,
+        PROP_CLIENT
 };
 
 #define GET_PRIVATE(o) \
@@ -80,24 +82,28 @@ struct _TrgTorrentPropsDialogPrivate {
     TrgFilesModel *filesModel;
     JsonObject *lastJson;
 
-    GtkWidget * size_lb;
-    GtkWidget * have_lb;
-    GtkWidget * dl_lb;
-    GtkWidget * ul_lb;
-    GtkWidget * state_lb;
-    GtkWidget * date_started_lb;
-    GtkWidget * eta_lb;
-    GtkWidget * last_activity_lb;
-    GtkWidget * error_lb;
-    GtkWidget * destination_lb;
-    GtkWidget * hash_lb;
-    GtkWidget * privacy_lb;
-    GtkWidget * origin_lb;
-    GtkTextBuffer * comment_buffer;
+    GtkWidget *size_lb;
+    GtkWidget *have_lb;
+    GtkWidget *dl_lb;
+    GtkWidget *ul_lb;
+    GtkWidget *state_lb;
+    GtkWidget *date_started_lb;
+    GtkWidget *eta_lb;
+    GtkWidget *last_activity_lb;
+    GtkWidget *error_lb;
+    GtkWidget *destination_lb;
+    GtkWidget *hash_lb;
+    GtkWidget *privacy_lb;
+    GtkWidget *origin_lb;
+    GtkTextBuffer *comment_buffer;
 };
 
 static void trg_torrent_props_dialog_set_property(GObject * object,
-        guint prop_id, const GValue * value, GParamSpec * pspec G_GNUC_UNUSED) {
+                                                  guint prop_id,
+                                                  const GValue * value,
+                                                  GParamSpec *
+                                                  pspec G_GNUC_UNUSED)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(object);
 
     switch (prop_id) {
@@ -117,29 +123,37 @@ static void trg_torrent_props_dialog_set_property(GObject * object,
 }
 
 static void trg_torrent_props_dialog_get_property(GObject * object,
-        guint prop_id, GValue * value, GParamSpec * pspec G_GNUC_UNUSED) {
+                                                  guint prop_id,
+                                                  GValue * value,
+                                                  GParamSpec *
+                                                  pspec G_GNUC_UNUSED)
+{
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 }
 
 static void trg_torrent_props_response_cb(GtkDialog * dialog, gint res_id,
-        gpointer data G_GNUC_UNUSED) {
+                                          gpointer data G_GNUC_UNUSED)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(dialog);
     JsonNode *request;
     JsonObject *args;
 
     if (priv->peersTv) {
         trg_tree_view_persist(TRG_TREE_VIEW(priv->peersTv),
-                TRG_TREE_VIEW_PERSIST_SORT | TRG_TREE_VIEW_PERSIST_LAYOUT);
+                              TRG_TREE_VIEW_PERSIST_SORT |
+                              TRG_TREE_VIEW_PERSIST_LAYOUT);
         if (priv->filesTv)
             trg_tree_view_persist(TRG_TREE_VIEW(priv->filesTv),
-                    TRG_TREE_VIEW_PERSIST_SORT | TRG_TREE_VIEW_PERSIST_LAYOUT);
+                                  TRG_TREE_VIEW_PERSIST_SORT |
+                                  TRG_TREE_VIEW_PERSIST_LAYOUT);
 
         if (priv->trackersTv)
             trg_tree_view_persist(TRG_TREE_VIEW(priv->trackersTv),
-                    TRG_TREE_VIEW_PERSIST_SORT | TRG_TREE_VIEW_PERSIST_LAYOUT);
+                                  TRG_TREE_VIEW_PERSIST_SORT |
+                                  TRG_TREE_VIEW_PERSIST_LAYOUT);
 
         if (res_id != GTK_RESPONSE_OK) {
-            gtk_widget_destroy(GTK_WIDGET(dialog) );
+            gtk_widget_destroy(GTK_WIDGET(dialog));
             json_array_unref(priv->targetIds);
             return;
         }
@@ -148,225 +162,238 @@ static void trg_torrent_props_response_cb(GtkDialog * dialog, gint res_id,
         args = node_get_arguments(request);
 
         json_object_set_int_member(args, FIELD_SEED_RATIO_MODE,
-                gtk_combo_box_get_active(GTK_COMBO_BOX
-                (priv->seedRatioMode) ));
+                                   gtk_combo_box_get_active(GTK_COMBO_BOX
+                                                            (priv->
+                                                             seedRatioMode)));
         json_object_set_int_member(args, FIELD_BANDWIDTH_PRIORITY,
-                gtk_combo_box_get_active(GTK_COMBO_BOX
-                (priv->bandwidthPriorityCombo) ) - 1);
+                                   gtk_combo_box_get_active(GTK_COMBO_BOX
+                                                            (priv->
+                                                             bandwidthPriorityCombo))
+                                   - 1);
 
         trg_json_widgets_save(priv->widgets, args);
         trg_json_widget_desc_list_free(priv->widgets);
 
-        dispatch_async(priv->client, request, on_generic_interactive_action,
-                priv->parent);
+        dispatch_async(priv->client, request,
+                       on_generic_interactive_action, priv->parent);
 
-        gtk_widget_destroy(GTK_WIDGET(dialog) );
+        gtk_widget_destroy(GTK_WIDGET(dialog));
     }
 }
 
-static void seed_ratio_mode_changed_cb(GtkWidget * w, gpointer data) {
+static void seed_ratio_mode_changed_cb(GtkWidget * w, gpointer data)
+{
     gtk_widget_set_sensitive(GTK_WIDGET(data),
-            gtk_combo_box_get_active(GTK_COMBO_BOX(w) ) == 1 ? TRUE : FALSE);
+                             gtk_combo_box_get_active(GTK_COMBO_BOX(w)) ==
+                             1 ? TRUE : FALSE);
 }
 
-static GtkWidget*
-info_page_new(TrgTorrentPropsDialog * dialog) {
+static GtkWidget *info_page_new(TrgTorrentPropsDialog * dialog)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(dialog);
     guint row = 0;
-    GtkTextBuffer * b;
+    GtkTextBuffer *b;
     GtkWidget *l, *w, *fr, *sw;
     GtkWidget *t = hig_workarea_create();
 
-    hig_workarea_add_section_title(t, &row, _( "Activity" ));
+    hig_workarea_add_section_title(t, &row, _("Activity"));
 
     /* size */
-    l = priv->size_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Torrent size:" ), l, NULL );
+    l = priv->size_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Torrent size:"), l, NULL);
 
     /* have */
-    l = priv->have_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Have:" ), l, NULL );
+    l = priv->have_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Have:"), l, NULL);
 
     /* downloaded */
-    l = priv->dl_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Downloaded:" ), l, NULL );
+    l = priv->dl_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Downloaded:"), l, NULL);
 
     /* uploaded */
-    l = priv->ul_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Uploaded:" ), l, NULL );
+    l = priv->ul_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Uploaded:"), l, NULL);
 
     /* state */
-    l = priv->state_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "State:" ), l, NULL );
+    l = priv->state_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("State:"), l, NULL);
 
     /* running for */
-    l = priv->date_started_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Running time:" ), l, NULL );
+    l = priv->date_started_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Running time:"), l, NULL);
 
     /* eta */
-    l = priv->eta_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Remaining time:" ), l, NULL );
+    l = priv->eta_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Remaining time:"), l, NULL);
 
     /* last activity */
-    l = priv->last_activity_lb = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Last activity:" ), l, NULL );
+    l = priv->last_activity_lb = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Last activity:"), l, NULL);
 
     /* error */
     l = g_object_new(GTK_TYPE_LABEL, "selectable", TRUE, "ellipsize",
-            PANGO_ELLIPSIZE_END, NULL );
-    hig_workarea_add_row(t, &row, _( "Error:" ), l, NULL );
+                     PANGO_ELLIPSIZE_END, NULL);
+    hig_workarea_add_row(t, &row, _("Error:"), l, NULL);
     priv->error_lb = l;
 
     hig_workarea_add_section_divider(t, &row);
-    hig_workarea_add_section_title(t, &row, _( "Details" ));
+    hig_workarea_add_section_title(t, &row, _("Details"));
 
     /* destination */
     l = g_object_new(GTK_TYPE_LABEL, "selectable", TRUE, "ellipsize",
-            PANGO_ELLIPSIZE_END, NULL );
-    hig_workarea_add_row(t, &row, _( "Location:" ), l, NULL );
+                     PANGO_ELLIPSIZE_END, NULL);
+    hig_workarea_add_row(t, &row, _("Location:"), l, NULL);
     priv->destination_lb = l;
 
     /* hash */
     l = g_object_new(GTK_TYPE_LABEL, "selectable", TRUE, "ellipsize",
-            PANGO_ELLIPSIZE_END, NULL );
-    hig_workarea_add_row(t, &row, _( "Hash:" ), l, NULL );
+                     PANGO_ELLIPSIZE_END, NULL);
+    hig_workarea_add_row(t, &row, _("Hash:"), l, NULL);
     priv->hash_lb = l;
 
     /* privacy */
-    l = gtk_label_new(NULL );
-    gtk_label_set_single_line_mode(GTK_LABEL( l ), TRUE);
-    hig_workarea_add_row(t, &row, _( "Privacy:" ), l, NULL );
+    l = gtk_label_new(NULL);
+    gtk_label_set_single_line_mode(GTK_LABEL(l), TRUE);
+    hig_workarea_add_row(t, &row, _("Privacy:"), l, NULL);
     priv->privacy_lb = l;
 
     /* origins */
     l = g_object_new(GTK_TYPE_LABEL, "selectable", TRUE, "ellipsize",
-            PANGO_ELLIPSIZE_END, NULL );
-    hig_workarea_add_row(t, &row, _( "Origin:" ), l, NULL );
+                     PANGO_ELLIPSIZE_END, NULL);
+    hig_workarea_add_row(t, &row, _("Origin:"), l, NULL);
     priv->origin_lb = l;
 
     /* comment */
-    b = priv->comment_buffer = gtk_text_buffer_new(NULL );
+    b = priv->comment_buffer = gtk_text_buffer_new(NULL);
     w = gtk_text_view_new_with_buffer(b);
-    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW( w ), GTK_WRAP_WORD);
-    gtk_text_view_set_editable(GTK_TEXT_VIEW( w ), FALSE);
-    sw = gtk_scrolled_window_new(NULL, NULL );
+    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(w), GTK_WRAP_WORD);
+    gtk_text_view_set_editable(GTK_TEXT_VIEW(w), FALSE);
+    sw = gtk_scrolled_window_new(NULL, NULL);
     gtk_widget_set_size_request(sw, 350, 36);
-    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW( sw ),
-            GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-    gtk_container_add(GTK_CONTAINER( sw ), w);
-    fr = gtk_frame_new(NULL );
-    gtk_frame_set_shadow_type(GTK_FRAME( fr ), GTK_SHADOW_IN);
-    gtk_container_add(GTK_CONTAINER( fr ), sw);
-    w = hig_workarea_add_tall_row(t, &row, _( "Comment:" ), fr, NULL );
-    gtk_misc_set_alignment(GTK_MISC( w ), 0.0f, 0.0f);
+    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
+                                   GTK_POLICY_AUTOMATIC,
+                                   GTK_POLICY_AUTOMATIC);
+    gtk_container_add(GTK_CONTAINER(sw), w);
+    fr = gtk_frame_new(NULL);
+    gtk_frame_set_shadow_type(GTK_FRAME(fr), GTK_SHADOW_IN);
+    gtk_container_add(GTK_CONTAINER(fr), sw);
+    w = hig_workarea_add_tall_row(t, &row, _("Comment:"), fr, NULL);
+    gtk_misc_set_alignment(GTK_MISC(w), 0.0f, 0.0f);
 
     hig_workarea_add_section_divider(t, &row);
     return t;
 }
 
-static void info_page_update(TrgTorrentPropsDialog *dialog, JsonObject *t,
-        TrgTorrentModel *torrentModel, GtkTreeIter *iter) {
+static void info_page_update(TrgTorrentPropsDialog * dialog,
+                             JsonObject * t,
+                             TrgTorrentModel * torrentModel,
+                             GtkTreeIter * iter)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(dialog);
     GtkTreeModel *model = GTK_TREE_MODEL(torrentModel);
-    gint64 sizeWhenDone, haveValid, downloaded, uploaded, percentDone, eta, activityDate, error;
+    gint64 sizeWhenDone, haveValid, downloaded, uploaded, percentDone, eta,
+        activityDate, error;
     gchar *statusString;
     guint flags;
     //const gchar * creator;
-    const gchar * str;
+    const gchar *str;
 
     char buf[512];
 
     gtk_tree_model_get(model, iter,
-            TORRENT_COLUMN_SIZEWHENDONE, &sizeWhenDone,
-            TORRENT_COLUMN_UPLOADED, &uploaded,
-            TORRENT_COLUMN_DOWNLOADED, &downloaded,
-            TORRENT_COLUMN_HAVE_VALID, &haveValid,
-            TORRENT_COLUMN_PERCENTDONE, &percentDone,
-            TORRENT_COLUMN_ETA, &eta,
-            TORRENT_COLUMN_LASTACTIVE, &activityDate,
-            TORRENT_COLUMN_STATUS, &statusString,
-            TORRENT_COLUMN_FLAGS, &flags,
-            TORRENT_COLUMN_ERROR, &error,
-            -1);
+                       TORRENT_COLUMN_SIZEWHENDONE, &sizeWhenDone,
+                       TORRENT_COLUMN_UPLOADED, &uploaded,
+                       TORRENT_COLUMN_DOWNLOADED, &downloaded,
+                       TORRENT_COLUMN_HAVE_VALID, &haveValid,
+                       TORRENT_COLUMN_PERCENTDONE, &percentDone,
+                       TORRENT_COLUMN_ETA, &eta,
+                       TORRENT_COLUMN_LASTACTIVE, &activityDate,
+                       TORRENT_COLUMN_STATUS, &statusString,
+                       TORRENT_COLUMN_FLAGS, &flags,
+                       TORRENT_COLUMN_ERROR, &error, -1);
 
     if (torrent_get_is_private(t))
-        str = _( "Private to this tracker -- DHT and PEX disabled" );
+        str = _("Private to this tracker -- DHT and PEX disabled");
     else
-        str = _( "Public torrent" );
+        str = _("Public torrent");
 
-    gtk_label_set_text(GTK_LABEL( priv->privacy_lb ), str);
+    gtk_label_set_text(GTK_LABEL(priv->privacy_lb), str);
 
     {
-        const gchar* creator = torrent_get_creator(t);
+        const gchar *creator = torrent_get_creator(t);
         gint64 dateCreated = torrent_get_date_created(t);
         gchar *dateStr = epoch_to_string(dateCreated);
 
         if (!creator)
-            g_snprintf(buf, sizeof(buf), _( "Created on %1$s" ), dateStr);
+            g_snprintf(buf, sizeof(buf), _("Created on %1$s"), dateStr);
         else
-            g_snprintf(buf, sizeof(buf), _( "Created by %1$s on %2$s" ),
-                    creator, dateStr);
+            g_snprintf(buf, sizeof(buf), _("Created by %1$s on %2$s"),
+                       creator, dateStr);
 
         g_free(dateStr);
-        gtk_label_set_text(GTK_LABEL( priv->origin_lb ), buf);
+        gtk_label_set_text(GTK_LABEL(priv->origin_lb), buf);
     }
 
-    gtk_text_buffer_set_text( priv->comment_buffer, torrent_get_comment(t), -1 );
-    gtk_label_set_text( GTK_LABEL( priv->destination_lb ), torrent_get_download_dir(t) );
+    gtk_text_buffer_set_text(priv->comment_buffer, torrent_get_comment(t),
+                             -1);
+    gtk_label_set_text(GTK_LABEL(priv->destination_lb),
+                       torrent_get_download_dir(t));
 
-    gtk_label_set_text( GTK_LABEL( priv->state_lb ), statusString );
+    gtk_label_set_text(GTK_LABEL(priv->state_lb), statusString);
     g_free(statusString);
 
     {
-        gchar *addedStr = epoch_to_string( torrent_get_added_date(t) );
-        gtk_label_set_text( GTK_LABEL( priv->date_started_lb ), addedStr );
+        gchar *addedStr = epoch_to_string(torrent_get_added_date(t));
+        gtk_label_set_text(GTK_LABEL(priv->date_started_lb), addedStr);
         g_free(addedStr);
     }
 
     /* eta */
 
     if (eta > 0) {
-        tr_strltime_long(buf, eta, sizeof( buf ));
+        tr_strltime_long(buf, eta, sizeof(buf));
         gtk_label_set_text(GTK_LABEL(priv->eta_lb), buf);
     } else {
-        gtk_label_set_text(GTK_LABEL(priv->eta_lb), _( "Unknown" ));
+        gtk_label_set_text(GTK_LABEL(priv->eta_lb), _("Unknown"));
     }
 
-    gtk_label_set_text( GTK_LABEL( priv->hash_lb ), torrent_get_hash(t) );
-    gtk_label_set_text( GTK_LABEL(priv->error_lb), error ? torrent_get_errorstr(t) : _("No errors"));
+    gtk_label_set_text(GTK_LABEL(priv->hash_lb), torrent_get_hash(t));
+    gtk_label_set_text(GTK_LABEL(priv->error_lb),
+                       error ? torrent_get_errorstr(t) : _("No errors"));
 
     if (flags & TORRENT_FLAG_ACTIVE) {
-        gtk_label_set_text(GTK_LABEL (priv->last_activity_lb),
-                _( "Active now" ));
+        gtk_label_set_text(GTK_LABEL(priv->last_activity_lb),
+                           _("Active now"));
     } else {
         gchar *activityStr = epoch_to_string(activityDate);
-        gtk_label_set_text(GTK_LABEL (priv->last_activity_lb), activityStr);
+        gtk_label_set_text(GTK_LABEL(priv->last_activity_lb), activityStr);
         g_free(activityStr);
     }
 
     tr_strlsize(buf, sizeWhenDone, sizeof(buf));
-    gtk_label_set_text(GTK_LABEL( priv->size_lb ), buf);
+    gtk_label_set_text(GTK_LABEL(priv->size_lb), buf);
 
     tr_strlsize(buf, downloaded, sizeof(buf));
-    gtk_label_set_text(GTK_LABEL( priv->dl_lb ), buf);
+    gtk_label_set_text(GTK_LABEL(priv->dl_lb), buf);
 
     tr_strlsize(buf, uploaded, sizeof(buf));
-    gtk_label_set_text(GTK_LABEL( priv->ul_lb ), buf);
+    gtk_label_set_text(GTK_LABEL(priv->ul_lb), buf);
 
     tr_strlsize(buf, haveValid, sizeof(buf));
-    gtk_label_set_text(GTK_LABEL( priv->have_lb ), buf);
+    gtk_label_set_text(GTK_LABEL(priv->have_lb), buf);
 }
 
 static GtkWidget *trg_props_limits_page_new(TrgTorrentPropsDialog * win,
-        JsonObject * json) {
+                                            JsonObject * json)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(win);
     GtkWidget *w, *tb, *t;
     guint row = 0;
@@ -376,74 +403,87 @@ static GtkWidget *trg_props_limits_page_new(TrgTorrentPropsDialog * win,
     hig_workarea_add_section_title(t, &row, _("Bandwidth"));
 
     w = trg_json_widget_check_new(&priv->widgets, json,
-            FIELD_HONORS_SESSION_LIMITS, _("Honor global limits"), NULL );
+                                  FIELD_HONORS_SESSION_LIMITS,
+                                  _("Honor global limits"), NULL);
     hig_workarea_add_wide_control(t, &row, w);
 
     w = priv->bandwidthPriorityCombo = gtr_combo_box_new_enum(_("Low"), 0,
-            _("Normal"), 1, _("High"), 2, NULL );
+                                                              _("Normal"),
+                                                              1, _("High"),
+                                                              2, NULL);
     gtk_combo_box_set_active(GTK_COMBO_BOX(w),
-            torrent_get_bandwidth_priority(json) + 1);
+                             torrent_get_bandwidth_priority(json) + 1);
 
-    hig_workarea_add_row(t, &row, _("Torrent priority:"), w, NULL );
+    hig_workarea_add_row(t, &row, _("Torrent priority:"), w, NULL);
 
     if (json_object_has_member(json, FIELD_QUEUE_POSITION)) {
-        w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_QUEUE_POSITION,
-                NULL, 0, INT_MAX, 1);
+        w = trg_json_widget_spin_new(&priv->widgets, json,
+                                     FIELD_QUEUE_POSITION, NULL, 0,
+                                     INT_MAX, 1);
         hig_workarea_add_row(t, &row, _("Queue Position:"), w, w);
     }
 
-    tb = trg_json_widget_check_new(&priv->widgets, json, FIELD_DOWNLOAD_LIMITED,
-            _("Limit download speed (KiB/s)"), NULL );
-    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_DOWNLOAD_LIMIT, tb,
-            0, INT_MAX, 1);
-    hig_workarea_add_row_w(t, &row, tb, w, NULL );
-
-    tb = trg_json_widget_check_new(&priv->widgets, json, FIELD_UPLOAD_LIMITED,
-            _("Limit upload speed (KiB/s)"), NULL );
-    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_UPLOAD_LIMIT, tb,
-            0, INT_MAX, 1);
-    hig_workarea_add_row_w(t, &row, tb, w, NULL );
+    tb = trg_json_widget_check_new(&priv->widgets, json,
+                                   FIELD_DOWNLOAD_LIMITED,
+                                   _("Limit download speed (KiB/s)"),
+                                   NULL);
+    w = trg_json_widget_spin_new(&priv->widgets, json,
+                                 FIELD_DOWNLOAD_LIMIT, tb, 0, INT_MAX, 1);
+    hig_workarea_add_row_w(t, &row, tb, w, NULL);
+
+    tb = trg_json_widget_check_new(&priv->widgets, json,
+                                   FIELD_UPLOAD_LIMITED,
+                                   _("Limit upload speed (KiB/s)"), NULL);
+    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_UPLOAD_LIMIT,
+                                 tb, 0, INT_MAX, 1);
+    hig_workarea_add_row_w(t, &row, tb, w, NULL);
 
     hig_workarea_add_section_title(t, &row, _("Seeding"));
 
-    w = priv->seedRatioMode = gtr_combo_box_new_enum(_("Use global settings"),
-            0, _("Stop seeding at ratio"), 1, _("Seed regardless of ratio"),
-            2, NULL );
+    w = priv->seedRatioMode =
+        gtr_combo_box_new_enum(_("Use global settings"), 0,
+                               _("Stop seeding at ratio"), 1,
+                               _("Seed regardless of ratio"), 2, NULL);
     gtk_combo_box_set_active(GTK_COMBO_BOX(w),
-            torrent_get_seed_ratio_mode(json));
-    hig_workarea_add_row(t, &row, _("Seed ratio mode:"), w, NULL );
+                             torrent_get_seed_ratio_mode(json));
+    hig_workarea_add_row(t, &row, _("Seed ratio mode:"), w, NULL);
 
-    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_SEED_RATIO_LIMIT,
-            NULL, 0, INT_MAX, 0.2);
+    w = trg_json_widget_spin_new(&priv->widgets, json,
+                                 FIELD_SEED_RATIO_LIMIT, NULL, 0, INT_MAX,
+                                 0.2);
     seed_ratio_mode_changed_cb(priv->seedRatioMode, w);
     g_signal_connect(G_OBJECT(priv->seedRatioMode), "changed",
-            G_CALLBACK(seed_ratio_mode_changed_cb), w);
+                     G_CALLBACK(seed_ratio_mode_changed_cb), w);
     hig_workarea_add_row(t, &row, _("Seed ratio limit:"), w, w);
 
     hig_workarea_add_section_title(t, &row, _("Peers"));
 
-    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_PEER_LIMIT, NULL,
-            0, INT_MAX, 5);
+    w = trg_json_widget_spin_new(&priv->widgets, json, FIELD_PEER_LIMIT,
+                                 NULL, 0, INT_MAX, 5);
     hig_workarea_add_row(t, &row, _("Peer limit:"), w, w);
 
     return t;
 }
 
-static void models_updated(TrgTorrentModel * model, gpointer data) {
+static void models_updated(TrgTorrentModel * model, gpointer data)
+{
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(data);
     GHashTable *ht = get_torrent_table(model);
     gint64 serial = trg_client_get_serial(priv->client);
     JsonObject *t;
     GtkTreeIter iter;
 
-    if (get_torrent_data(ht, json_array_get_int_element(priv->targetIds, 0), &t,
-            &iter) && t != priv->lastJson) {
-        trg_files_model_update(priv->filesModel, GTK_TREE_VIEW(priv->filesTv),
-                serial, t, TORRENT_GET_MODE_UPDATE);
-        trg_peers_model_update(priv->peersModel, TRG_TREE_VIEW(priv->peersTv),
-                serial, t, TORRENT_GET_MODE_UPDATE);
+    if (get_torrent_data
+        (ht, json_array_get_int_element(priv->targetIds, 0), &t, &iter)
+        && t != priv->lastJson) {
+        trg_files_model_update(priv->filesModel,
+                               GTK_TREE_VIEW(priv->filesTv), serial, t,
+                               TORRENT_GET_MODE_UPDATE);
+        trg_peers_model_update(priv->peersModel,
+                               TRG_TREE_VIEW(priv->peersTv), serial, t,
+                               TORRENT_GET_MODE_UPDATE);
         trg_trackers_model_update(priv->trackersModel, serial, t,
-                TORRENT_GET_MODE_UPDATE);
+                                  TORRENT_GET_MODE_UPDATE);
         info_page_update(TRG_TORRENT_PROPS_DIALOG(data), t, model, &iter);
 
         priv->lastJson = t;
@@ -451,52 +491,61 @@ static void models_updated(TrgTorrentModel * model, gpointer data) {
 }
 
 static GObject *trg_torrent_props_dialog_constructor(GType type,
-        guint n_construct_properties, GObjectConstructParam * construct_params) {
+                                                     guint
+                                                     n_construct_properties,
+                                                     GObjectConstructParam
+                                                     * construct_params)
+{
     GObject *object = G_OBJECT_CLASS
-    (trg_torrent_props_dialog_parent_class) ->constructor(type,
-            n_construct_properties, construct_params);
+        (trg_torrent_props_dialog_parent_class)->constructor(type,
+                                                             n_construct_properties,
+                                                             construct_params);
 
     TrgTorrentPropsDialog *propsDialog = TRG_TORRENT_PROPS_DIALOG(object);
     GtkWindow *window = GTK_WINDOW(object);
     TrgTorrentPropsDialogPrivate *priv = GET_PRIVATE(object);
 
-    GtkTreeSelection *selection = gtk_tree_view_get_selection(
-            GTK_TREE_VIEW(priv->tv) );
+    GtkTreeSelection *selection =
+        gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->tv));
     gint rowCount = gtk_tree_selection_count_selected_rows(selection);
     TrgPrefs *prefs = trg_client_get_prefs(priv->client);
     gboolean showDetails = trg_prefs_get_int(prefs, TRG_PREFS_KEY_STYLE,
-            TRG_PREFS_GLOBAL) != TRG_STYLE_CLASSIC && rowCount == 1;
+                                             TRG_PREFS_GLOBAL) !=
+        TRG_STYLE_CLASSIC && rowCount == 1;
 
     JsonObject *json;
     GtkTreeIter iter;
     GtkWidget *notebook, *contentvbox;
 
     get_torrent_data(trg_client_get_torrent_table(priv->client),
-            trg_mw_get_selected_torrent_id(priv->parent), &json, &iter);
+                     trg_mw_get_selected_torrent_id(priv->parent), &json,
+                     &iter);
     priv->targetIds = build_json_id_array(priv->tv);
 
     if (rowCount > 1) {
-        gchar *windowTitle = g_strdup_printf(
-                _("Multiple (%d) torrent properties"), rowCount);
+        gchar *windowTitle =
+            g_strdup_printf(_("Multiple (%d) torrent properties"),
+                            rowCount);
         gtk_window_set_title(window, windowTitle);
         g_free(windowTitle);
     } else if (rowCount == 1) {
         gtk_window_set_title(window, torrent_get_name(json));
     }
 
-    gtk_window_set_transient_for(window, GTK_WINDOW(priv->parent) );
+    gtk_window_set_transient_for(window, GTK_WINDOW(priv->parent));
     gtk_window_set_destroy_with_parent(window, 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_torrent_props_response_cb), NULL);
+                     G_CALLBACK(trg_torrent_props_response_cb), NULL);
 
     notebook = gtk_notebook_new();
 
@@ -506,63 +555,74 @@ static GObject *trg_torrent_props_dialog_constructor(GType type,
         /* Information */
 
         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-                info_page_new(propsDialog), gtk_label_new(_("Information")));
+                                 info_page_new(propsDialog),
+                                 gtk_label_new(_("Information")));
         info_page_update(propsDialog, json, priv->torrentModel, &iter);
 
         /* Files */
 
         priv->filesModel = trg_files_model_new();
-        priv->filesTv = trg_files_tree_view_new(priv->filesModel, priv->parent,
-                priv->client, "TrgFilesTreeView-dialog");
-        trg_files_model_update(priv->filesModel, GTK_TREE_VIEW(priv->filesTv),
-                serial, json, TORRENT_GET_MODE_FIRST);
+        priv->filesTv =
+            trg_files_tree_view_new(priv->filesModel, priv->parent,
+                                    priv->client,
+                                    "TrgFilesTreeView-dialog");
+        trg_files_model_update(priv->filesModel,
+                               GTK_TREE_VIEW(priv->filesTv), serial, json,
+                               TORRENT_GET_MODE_FIRST);
         gtk_widget_set_sensitive(GTK_WIDGET(priv->filesTv), TRUE);
         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-                my_scrolledwin_new(GTK_WIDGET
-                (priv->filesTv) ), gtk_label_new(_("Files")));
+                                 my_scrolledwin_new(GTK_WIDGET
+                                                    (priv->filesTv)),
+                                 gtk_label_new(_("Files")));
 
         /* Peers */
 
         priv->peersModel = trg_peers_model_new();
         priv->peersTv = trg_peers_tree_view_new(prefs, priv->peersModel,
-                "TrgPeersTreeView-dialog");
-        trg_peers_model_update(priv->peersModel, TRG_TREE_VIEW(priv->peersTv),
-                serial, json, TORRENT_GET_MODE_FIRST);
+                                                "TrgPeersTreeView-dialog");
+        trg_peers_model_update(priv->peersModel,
+                               TRG_TREE_VIEW(priv->peersTv), serial, json,
+                               TORRENT_GET_MODE_FIRST);
         gtk_widget_set_sensitive(GTK_WIDGET(priv->peersTv), TRUE);
         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-                my_scrolledwin_new(GTK_WIDGET
-                (priv->peersTv) ), gtk_label_new(_("Peers")));
+                                 my_scrolledwin_new(GTK_WIDGET
+                                                    (priv->peersTv)),
+                                 gtk_label_new(_("Peers")));
 
         /* Trackers */
 
         priv->trackersModel = trg_trackers_model_new();
         priv->trackersTv = trg_trackers_tree_view_new(priv->trackersModel,
-                priv->client, priv->parent, "TrgTrackersTreeView-dialog");
-        trg_trackers_tree_view_new_connection(priv->trackersTv, priv->client);
+                                                      priv->client,
+                                                      priv->parent,
+                                                      "TrgTrackersTreeView-dialog");
+        trg_trackers_tree_view_new_connection(priv->trackersTv,
+                                              priv->client);
         trg_trackers_model_update(priv->trackersModel, serial, json,
-                TORRENT_GET_MODE_FIRST);
+                                  TORRENT_GET_MODE_FIRST);
         gtk_widget_set_sensitive(GTK_WIDGET(priv->trackersTv), TRUE);
         gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-                my_scrolledwin_new(GTK_WIDGET
-                (priv->trackersTv) ), gtk_label_new(_("Trackers")));
+                                 my_scrolledwin_new(GTK_WIDGET
+                                                    (priv->trackersTv)),
+                                 gtk_label_new(_("Trackers")));
 
         g_object_unref(priv->trackersModel);
         g_object_unref(priv->filesModel);
         g_object_unref(priv->peersModel);
 
         g_signal_connect_object(priv->torrentModel, "update", G_CALLBACK
-        (models_updated), object, G_CONNECT_AFTER);
+                                (models_updated), object, G_CONNECT_AFTER);
 
         priv->lastJson = json;
     }
 
     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
-            trg_props_limits_page_new(propsDialog, json),
-            gtk_label_new(_("Limits")));
+                             trg_props_limits_page_new(propsDialog, json),
+                             gtk_label_new(_("Limits")));
 
     gtk_container_set_border_width(GTK_CONTAINER(notebook), GUI_PAD);
 
-    contentvbox = gtk_dialog_get_content_area(GTK_DIALOG(object) );
+    contentvbox = gtk_dialog_get_content_area(GTK_DIALOG(object));
     gtk_box_pack_start(GTK_BOX(contentvbox), notebook, TRUE, TRUE, 0);
 
     gtk_window_set_default_size(window, 500, 500);
@@ -570,8 +630,9 @@ static GObject *trg_torrent_props_dialog_constructor(GType type,
     return object;
 }
 
-static void trg_torrent_props_dialog_class_init(
-        TrgTorrentPropsDialogClass * klass) {
+static void trg_torrent_props_dialog_class_init(TrgTorrentPropsDialogClass
+                                                * klass)
+{
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
     object_class->constructor = trg_torrent_props_dialog_constructor;
@@ -581,41 +642,74 @@ static void trg_torrent_props_dialog_class_init(
     g_type_class_add_private(klass, sizeof(TrgTorrentPropsDialogPrivate));
 
     g_object_class_install_property(object_class, PROP_TREEVIEW,
-            g_param_spec_object("torrent-tree-view", "TrgTorrentTreeView",
-                    "TrgTorrentTreeView", TRG_TYPE_TORRENT_TREE_VIEW,
-                    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
-                            | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK
-                            | G_PARAM_STATIC_BLURB));
+                                    g_param_spec_object
+                                    ("torrent-tree-view",
+                                     "TrgTorrentTreeView",
+                                     "TrgTorrentTreeView",
+                                     TRG_TYPE_TORRENT_TREE_VIEW,
+                                     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_TORRENT_MODEL,
-            g_param_spec_object("torrent-model", "TrgTorrentModel",
-                    "TrgTorrentModel", TRG_TYPE_TORRENT_MODEL,
-                    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
-                            | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK
-                            | G_PARAM_STATIC_BLURB));
+                                    g_param_spec_object("torrent-model",
+                                                        "TrgTorrentModel",
+                                                        "TrgTorrentModel",
+                                                        TRG_TYPE_TORRENT_MODEL,
+                                                        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_WINDOW,
-            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_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_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));
 }
 
-static void trg_torrent_props_dialog_init(
-        TrgTorrentPropsDialog * self G_GNUC_UNUSED) {
+static void trg_torrent_props_dialog_init(TrgTorrentPropsDialog *
+                                          self G_GNUC_UNUSED)
+{
 }
 
 TrgTorrentPropsDialog *trg_torrent_props_dialog_new(GtkWindow * window,
-        TrgTorrentTreeView * treeview, TrgTorrentModel * torrentModel,
-        TrgClient * client) {
+                                                    TrgTorrentTreeView *
+                                                    treeview,
+                                                    TrgTorrentModel *
+                                                    torrentModel,
+                                                    TrgClient * client)
+{
     return g_object_new(TRG_TYPE_TORRENT_PROPS_DIALOG, "torrent-tree-view",
-            treeview, "torrent-model", torrentModel, "parent-window", window,
-            "trg-client", client, NULL );
+                        treeview, "torrent-model", torrentModel,
+                        "parent-window", window, "trg-client", client,
+                        NULL);
 }
diff --git a/src/trg-tree-view.c b/src/trg-tree-view.c
index 3f7a289..3258d94 100644
--- a/src/trg-tree-view.c
+++ b/src/trg-tree-view.c
@@ -425,8 +425,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
             gtk_cell_renderer_text_new();
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer, "text",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
 
         break;
@@ -435,8 +434,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "speed-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_EPOCH:
@@ -444,8 +442,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "epoch-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_ETA:
@@ -453,8 +450,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "eta-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_SIZE:
@@ -462,8 +458,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "size-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_PROG:
@@ -471,8 +466,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_RATIO:
@@ -480,8 +474,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "ratio-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_WANTED:
@@ -506,8 +499,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "priority-value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_NUMGTZERO:
@@ -515,8 +507,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     case TRG_COLTYPE_NUMGTEQZERO:
@@ -524,8 +515,7 @@ trg_tree_view_add_column_after(TrgTreeView * tv,
         column = gtk_tree_view_column_new_with_attributes(desc->header,
                                                           renderer,
                                                           "value",
-                                                          desc->
-                                                          model_column,
+                                                          desc->model_column,
                                                           NULL);
         break;
     default:
@@ -702,8 +692,7 @@ void trg_tree_view_setup_columns(TrgTreeView * tv)
                                                                  json_node_get_string
                                                                  ((JsonNode
                                                                    *)
-                                                                  cli->
-                                                                  data));
+                                                                  cli->data));
         if (desc) {
             gint64 width = json_node_get_int((JsonNode *) wli->data);
             trg_tree_view_add_column(tv, desc, width);